Aller au contenu

Fonctions agrégées

Actuellement, 6 fonctions d'agrégation sont prises en charge.

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

  • Existence () -> valeurs booléennes

  • Somme (colonnes)-> Tout

  • Moyenne (colonne)-> Tout

  • Minutes (colonnes)-> tout

  • Maximum (colonnes)-> Tout

  • Query Set Agent pour

    • QuerysetProxy.count(distinct=True) Méthodes
    • QuerysetProxy.exists() Méthode
    • QuerysetProxy.sum(colonnes) Méthode
    • QuerysetProxy.avg(colonnes) Méthode
    • QuerysetProxy.min(colonne) Méthode
    • QuerysetProxy.max(colonne) Méthode

Compter les

count(distinct: bool = True) -> int

Renvoie le nombre de lignes correspondant à une condition donnée (c'est-à-dire appliquer des filtres et des exclusions). si distinct est True (valeur par défaut), cela renvoie le nombre de lignes primaires sélectionnées. si False, le nombre sera le nombre total de lignes renvoyées (y compris les lignes supplémentaires pour les connexions de table sélectionnées un à plusieurs ou plusieurs à plusieurs). False est un comportement hérité (défectueux) des flux de travail qui en dépendent.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Classe Book(modèle ormar):
    ormar_config = ormar.OrmarConfig(
        database=databases.Database(DATABASE_URL),
        metadata=sqlalchemy.MetaData(),
        tablename="livre"
    )

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    author: str = ormar.String(max_length=100)
    genre: str = ormar.String(
        max_length=100,
        default="Fiction",
        choices=["Fiction", "Aventure", "Historique", "Fantasy"],
    )


# returns count of rows in db pour modèle de livre
no_of_books = await Book.objects.count()

Existence de

Existence () -> valeurs booléennes

Renvoie une valeur booléenne pour confirmer qu 'il y a des lignes qui répondent à un critère donné (appliqué avec des filtres et des exclusions)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Classe Book(modèle ormar):
    ormar_config = ormar.OrmarConfig(
        database=databases.Database(DATABASE_URL),
        metadata=sqlalchemy.MetaData(),
        tablename="livre"
    )

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    author: str = ormar.String(max_length=100)
    genre: str = ormar.String(
        max_length=100,
        default="Fiction",
        choices=["Fiction", "Aventure", "Historique", "Fantasy"],
    )


# returns a boolean value if given row exists
has_sample = await Book.objects.filter(title ='Sample').exists()

et

Somme (colonnes)-> Tout

Renvoie la valeur de la somme des colonnes correspondant à une condition donnée (applique un filtre, exclut si défini précédemment).

Vous pouvez passer un ou plusieurs noms de colonnes, y compris les colonnes associées.

À partir de maintenant, chaque colonne passée est agrégée individuellement (donc sum(col1+col2) est impossible, vous pouvez utiliser sum(col1, col2) et ajouter 2 sommes retournées en python).

Vous ne pouvez pas additionner une colonne non numérique.

Si vous agrégez une colonne, une seule valeur est directement retournée comme résultat Si vous agrégez plusieurs colonnes, un dictionnaire contenant la paire colonne: résultat est retourné.

Le modèle donné est le suivant

 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)

Exemple d'utilisation peut ressembler à ceci

 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
author = await Author(nom ="Author 1").save()
await Book(title="Book 1", year=1920, ranking=3, author=author).save()
await Book(titre ="Book 2", année =1930, ranking=1, author=author).save()
await Book(title="Book 3", year=1923, ranking=5, author=author).save()

assert await Book.objects.sum("année") == 5773
résultat = await Book.objects.sum(["année", "classement"])
assert result == dict(année =5773, classement =9)

Essayez:
    # cannot sum string colonne
    await Book.objects.sum("titre")
Except ormar.QueryDefinitionError:
    par PASS

assert await Author.objects.select_related("books").sum("books__year") == 5773
result = await Author.objects.select_related("livres").sum(
    ["Books__year", "Books__ranking"]
)
assert result == dict(books__year=5773, books__ranking=9)

Assert (
    await Author.objects.select_related("livres")
    .filter(books__year__lt=1925)
    .sum("livres__année")
    == 3843
)

moyenne

Moyenne (colonne)-> Tout

Renvoie la moyenne des colonnes correspondant aux lignes pour une condition donnée (applique un filtre, exclut si défini précédemment).

Vous pouvez passer un ou plusieurs noms de colonnes, y compris les colonnes associées.

À partir de maintenant, chaque colonne passée est agrégée individuellement (donc sum(col1+col2) est impossible, vous pouvez utiliser sum(col1, col2) et ajouter 2 sommes retournées en python).

Vous ne pouvez pas faire la moyenne des colonnes non numériques.

Si vous agrégez une colonne, une seule valeur est directement retournée comme résultat Si vous agrégez plusieurs colonnes, un dictionnaire contenant la paire colonne: résultat est retourné.

 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)

Exemple d'utilisation peut ressembler à ceci

 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
author = await Author(name="Author 1").save()
await Book(title="Book 1", year=1920, ranking=3, author=author).save()
await Book(titre ="Book 2", année =1930, ranking=1, author=author).save()
await Book(title="Book 3", year=1923, ranking=5, author=author).save()

assert round(float(await Book.objects.avg("année")), 2) == 1924,33
result = await Book.objects.avg(["année", "classement"])
assert round(float(result.get("year")), 2) == 1924,33
assert result.get("ranking") == 3.0

Essayez:
    # cannot avg string colonne
    await Book.objects.avg("title")
Except ormar.QueryDefinitionError:
    par PASS

result = await Author.objects.select_related("books").avg("books__year")
assert round(float(result), 2) == 1924,33
result = await Author.objects.select_related("livres").avg(
    ["Books__year", "Books__ranking"]
)
assert round(float(result.get("books__year")), 2) == 1924,33
assert result.get("books__ranking") == 3.0

Assert (
    await Author.objects.select_related("livres")
    .filter(books__year__lt=1925)
    .avg("books__year")
    == 1921.5
)

minutes pour

Minutes (colonnes)-> tout

Renvoie la valeur minimale de la colonne correspondant à la ligne d'une condition donnée (appliquée avec le filtre, exclue si elle est définie précédemment).

Vous pouvez passer un ou plusieurs noms de colonnes, y compris les colonnes associées.

À partir de maintenant, chaque colonne passée est agrégée individuellement (donc sum(col1+col2) est impossible, vous pouvez utiliser sum(col1, col2) et ajouter 2 sommes retournées en python).

Si vous agrégez une colonne, une seule valeur est directement retournée comme résultat Si vous agrégez plusieurs colonnes, un dictionnaire contenant la paire colonne: résultat est retourné.

 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)

Un exemple d'utilisation peut ressembler à ceci

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
author = await Author(name="Author 1").save()
await Book(title="Book 1", year=1920, ranking=3, author=author).save()
await Book(titre ="Book 2", année =1930, ranking=1, author=author).save()
await Book(title="Book 3", year=1923, ranking=5, author=author).save()

assert await Book.objects.min("année") == 1920
result = await Book.objects.min(["année", "classement"])
assert result == dict(année =1920, classement =1)

assert await Book.objects.min("title") == "Book 1"

assert await Author.objects.select_related("books").min("books__year") == 1920
result = await Author.objects.select_related("livres").min(
    ["Books__year", "Books__ranking"]
)
assert result == dict(books__year=1920, books__ranking=1)

Assert (
    await Author.objects.select_related("livres")
    .filter(books__year__gt=1925).
    .min("livres__année")
    == 1930
)

Maximum de la limite

Maximum (colonnes)-> Tout

Renvoie la valeur maximale de la colonne correspondant à la ligne d'une condition donnée (appliquée avec le filtre, exclue si elle est définie précédemment).

Renvoie la valeur minimale de la colonne correspondant à la ligne d'une condition donnée (appliquée avec le filtre, exclue si elle est définie précédemment).

Vous pouvez passer un ou plusieurs noms de colonnes, y compris les colonnes associées.

À partir de maintenant, chaque colonne passée est agrégée individuellement (donc sum(col1+col2) est impossible, vous pouvez utiliser sum(col1, col2) et ajouter 2 sommes retournées en python).

Si vous agrégez une colonne, une seule valeur est directement retournée comme résultat Si vous agrégez plusieurs colonnes, un dictionnaire contenant la paire colonne: résultat est retourné.

 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)

Un exemple d'utilisation peut ressembler à ceci

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
author = await Author(name="Author 1").save()
await Book(title="Book 1", year=1920, ranking=3, author=author).save()
await Book(titre ="Book 2", année =1930, ranking=1, author=author).save()
await Book(title="Book 3", year=1923, ranking=5, author=author).save()

assert await Book.objects.max("année") == 1930
result = await Book.objects.max(["année", "classement"])
assert result == dict(année =1930, classement =5)

assert await Book.objects.max("title") == "Book 3"

assert await Author.objects.select_related("books").max("books__year") == 1930
result = await Author.objects.select_related("livres").max(
    ["Books__year", "Books__ranking"]
)
assert result == dict(books__year=1930, books__ranking=5)

Assert (
    await Author.objects.select_related("livres")
    .filter(books__year__lt=1925)
    .max(livres__année)
    == 1923
)

La méthode QuerysetProxy

Lorsque vous accédez directement au champ ManyToMany associé ainsi qu'à la clé ReverseForeignKey, une liste des modèles associés est renvoyée.

Mais en même temps, il expose un sous-ensemble de l'API QuerySet, de sorte que vous pouvez filtrer, créer, sélectionner des modèles pertinents, etc. directement à partir du modèle parent.

Compter les

Exactement la même chose que la fonction count ci-dessus, mais vous permet de sélectionner une colonne à partir d'un objet pertinent à l'autre extrémité de la relation.

!!!conseil Pour en savoir plus sur Querysetproxy, visitez la section Querysetproxy

Existence de

Exactement comme la fonction de présence ci-dessus, mais vous permet de sélectionner une colonne à partir d'un objet associé à l'autre extrémité de la relation.

et

Exactement comme la fonction sum ci-dessus, mais vous permet de sommer les colonnes des objets associés à l'autre extrémité de la relation.

Moyenne

Exactement comme la fonction avg ci-dessus, mais vous permet de faire la moyenne des colonnes des objets associés à l'autre extrémité de la relation.

minutes pour

Exactement comme la fonction min ci-dessus, mais vous permet de sélectionner le moins de colonnes parmi les objets associés à l'autre extrémité de la relation.

Maximum de la limite

Exactement comme la fonction max ci-dessus, mais vous permet de sélectionner la plus grande colonne parmi les objets associés à l'autre extrémité de la relation.

!!!conseil Pour en savoir plus sur Querysetproxy, visitez la section Querysetproxy