Zum Inhalt

Sammelfunktion

Derzeit werden sechs Aggregatfunktionen unterstützt.

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

  • vorhanden ()-> boolescher Wert

  • Gesamt (Liste)-> willkürlich

  • Durchschnitt (Spalte)-> willkürlich

  • Minuten (Spalten)-> willkürlich

  • Maximum (Spalte)-> willkürlich

  • Frage an den Vereinsvertreter

    • QuerysetProxy.count(distinct=True) Die Methode
    • Die QuerysetProxy. exists ()-Methode
    • QuerysetProxy. sum (columns)-Methode Bearbeiten
    • QuerysetProxy. avg (columns)-Methode Bearbeiten
    • QuerysetProxy. min (column)-Methode Bearbeiten
    • QuerysetProxy. max (Spalten) Methode

Anzahl Anzahl

count(distinct: bool = True) -> int

Gibt eine Anzahl von Zeilen zurück, die der gegebenen Bedingung entsprechen (d. h. Filter und Ausschlüsse werden angewendet) Wenn distinct (der Standardwert) ist, wird die ausgewählte primäre Zeile zurückgegeben, wenn False, die Anzahl der zurückgegebenen Zeilen (einschließlich einer zusätzlichen Zeile für ein Paar mehr oder mehr Paare von links select_lated-Tabellenverbindungen) False ist das Legacy-Verhalten (fehlerhaft) des Workflows, das davon abhängt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klasse Buch (ormar. model):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank. Datenbank (DATABASE_URL),
        metadata = sqlalchemy. metadata (), oder
        tabellenname ="Buch"
    )

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    title: str = ormar. String (max_length = 200)
    author: str = ormar. String (max_length = 100)[Bearbeiten | Quelltext bearbeiten]
    @ RG: (
        max_length = 100 Zeichen
        default ="Fiktion",
        Choices =["Fantasie","Abenteuer","Geschichte","Fantasie"],
    )


Returns Count of Rows in DB für Bücher Modell
no_of_books = await Book. objects. count ()[Bearbeiten | Quelltext bearbeiten]

Existiert

vorhanden ()-> boolesche Werte

Gibt einen booleschen Wert zurück, um zu bestätigen, dass eine Zeile eine bestimmte Bedingung erfüllt (gilt mit Filtern und Ausschlüssen)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klasse Buch (ormar. model):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank. Datenbank (DATABASE_URL),
        metadata = sqlalchemy. metadata (), oder
        tabName ="Buch"
    )

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    title: str = ormar. String (max_length = 200)
    author: str = ormar. String (max_length = 100)[Bearbeiten | Quelltext bearbeiten]
    @ RG: (
        max_length = 100 Zeichen
        default ="Fiktion",
        Choices =["Fantasie","Abenteuer","Geschichte","Fantasie"],
    )


#returns a boolean value if given row exists/gibt einen booleschen Wert zurück, wenn Row Exists gegeben wird
has_sample = await Book. objects. filter (title ='Sample'). exists ()()(Übersetzung)

und

Gesamt (Liste)-> willkürlich

Gibt den Gesamtwert der Spalte für die Zeilen zurück, die mit der angegebenen Bedingung übereinstimmen (Filter anwenden, ausgeschlossen, wenn zuvor festgelegt).

Sie können einen oder mehrere Spaltennamen , einschließlich der zugehörigen Spalten , übergeben .

Ab jetzt wird jede übergebene Spalte separat aggregiert (so dass sum (col1 + col2) nicht möglich ist , können Sie sum (col1 , col2) verwenden und dann 2 zurückgegebene Summen in Python hinzufügen)

Sie können nicht auf nicht-numerische Spalten fragen .

Gibt einen einzelnen Wert als Ergebnis zurück , wenn mehrere Spalten aggregiert werden , gibt ein Dictionary mit dem Ergebnispaar column : zurück

Gegeben sind folgende Modelle

 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)

Beispiele für die Verwendung können wie folgt aussehen

 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 (name = " Author 1 ") . save () () ist die
await Book (title = " Book 1 " , year = 1920 , ranking = 3 , author = author) . save () (siehe auch : await Book = " Book 1 " , year = 1920 , ranking = 3 , author = author) .
await Book (title = " Book2 " , year = 1930 , ranking = 1 , author = author) . save ()
await Book (title = " Book 3 " , Jahr = 1923 , ranking = 5 , author = author) . save ()

assert await Book . objects . sum (" Jahr ") = = 5773
result = await Book . objects . sum ([ " Jahr " , " Rang " ])
assert result = = dict (year = 5773 , ranking = 9) Ergebnis : = dict (Jahr = 5773 , Rang = 9)

versuchen :
    kann kein String column
    await Book . objects . sum (" title ") (" Inhalt ")
Ausnahme ormar . QueryDefinitionError :
    Durchreise

Assert Await UbersetzungenAuthor.objects.select_ related (" books ") . sum (" books _ _ year ") = 5773
ergebnis = awaitAuthor.objects.selectDie Buchreihe „ Bücher " (
    [ " Bücher _ Jahr " , " Bücher _ Ranking " ]
)
assert result = = dict (books _ _ year = 5773 , books _ _ ranking = 9) Bearbeiten

eingeblendet (
    Await sehenAuthor.objects.selectBücher („ Bücher ")
    . filter (Bücher _ _ Jahr _ _ lt = 1925)
    . sum (" Bücher _ Jahr ")
    == 3843
)

Durchschnittlich

Durchschnitt (Spalte) - > willkürlich

Gibt den Mittelwert der Spalte für eine Zeile zurück , die einer bestimmten Bedingung entspricht (Filter anwenden , ausgeschlossen , wenn zuvor festgelegt) .

Sie können einen oder mehrere Spaltennamen , einschließlich der zugehörigen Spalten , übergeben .

Ab jetzt wird jede übergebene Spalte separat aggregiert (so dass sum (col1 + col2) nicht möglich ist , können Sie sum (col1 , col2) verwenden und dann 2 zurückgegebene Summen in Python hinzufügen)

Sie können keinen Mittelwert für eine nicht numerische Spalte angeben .

Gibt einen einzelnen Wert als Ergebnis zurück , wenn mehrere Spalten aggregiert werden , gibt ein Dictionary mit dem Ergebnispaar column : zurück

 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)

Beispielverwendung kann wie folgt aussehen

 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 () () ist die
await Book (title = " Book 1 " , year = 1920 , ranking = 3 , author = author) . save () (siehe auch : await Book = " Book 1 " , year = 1920 , ranking = 3 , author = author) .
await Book (title = " Book2 " , year = 1930 , ranking = 1 , author = author) . save ()
await Book (title = " Book 3 " , Jahr = 1923 , ranking = 5 , author = author) . save ()

assert round (float (await Book . objects . avg (" year "))) , 2) = = 1924.33
result = await Book . objects . avg ([ " jahr " , " ranking " ])
assert round (float (result . get (" year "))) , 2) = 1924.33
Ergebnis (" Rang ") = 3.0

versuchen :
    # kann nicht AVG String Column
    await Buch . objects . avg (" title ") Bearbeiten
Ausnahme ormar . QueryDefinitionError :
    Durchreise

ergebnis = awaitAuthor.objects.select_ related (" Bücher ") . avg (" Bücher _ _ Jahr ")
assert round (float (result) , 2) = 1924,33
ergebnis = awaitAuthor.objects.selectBuchbeschreibung (
    [ " Bücher _ Jahr " , " Bücher _ Ranking " ]
)
assert round (float (result . get (" books _ _ year ")) , 2) = = 1924.33
assert result . get (" books _ _ ranking ") = = 3.0 (" Das Ergebnis wird geladen ")

eingeblendet (
    Await istAuthor.objects.selectBücher („ Bücher ")
    . filter (Bücher _ _ Jahr _ _ lt = 1925)
    . avg (" Bücher _ Jahr ")
    == 1921.5
)

Minuten .

Minuten (Spalte) - > willkürlich

Gibt den Mindestwert der Spalte für die Zeile zurück , die mit einer bestimmten Bedingung übereinstimmt (gilt mit dem Filter und wird ausgeschlossen , wenn zuvor festgelegt) .

Sie können einen oder mehrere Spaltennamen übergeben , einschließlich der zugehörigen Spalten .

Ab jetzt wird jede übergebene Spalte separat aggregiert (so dass sum (col1 + col2) nicht möglich ist , können Sie sum (col1 , col2) verwenden und dann 2 zurückgegebene Summen in Python hinzufügen)

Gibt einen einzelnen Wert als Ergebnis zurück , wenn mehrere Spalten aggregiert werden , gibt ein Dictionary mit dem Ergebnispaar column : zurück

 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)

Beispiele für die Verwendung können wie folgt aussehen

 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 () () ist die
await Book (title = " Book 1 " , year = 1920 , ranking = 3 , author = author) . save () (siehe auch : await Book = " Book 1 " , year = 1920 , ranking = 3 , author = author) .
await Book (title = " Book2 " , year = 1930 , ranking = 1 , author = author) . save ()
await Book (title = " Book 3 " , Jahr = 1923 , ranking = 5 , author = author) . save ()

assert await Book . objects . min (" Jahr ") = = 1920
result = await Book . objects . min ([ " Jahr " , " Ranking " ])
assert result = = dict (Jahr = 1920 , Rang = 1)

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

Assert Await hinzufügenAuthor.objects.select_ related (" Bücher ") . min (" Bücher _ _ Jahr ") = 1920
ergebnis = awaitAuthor.objects.selectBücher („ Bücher ") (
    [ " Bücher _ Jahr " , " Bücher _ Ranking " ]
)
assert result = = dict (books _ _ year = 1920 , books _ _ ranking = 1) Bearbeiten

eingeblendet (
    Await istAuthor.objects.selectBücher („ Bücher ")
    . filter (Bücher _ _ Jahr _ _ gt = 1925)
    . min (" Bücher _ Jahr ")
    == 1930
)

Höchstens

Maximum (Spalte) - > willkürlich

Gibt den maximalen Wert der Spalte für die Zeile zurück , die mit einer bestimmten Bedingung übereinstimmt (gilt mit dem Filter und wird ausgeschlossen , wenn zuvor festgelegt) .

Gibt den Mindestwert der Spalte für die Zeile zurück , die mit einer bestimmten Bedingung übereinstimmt (gilt mit dem Filter und wird ausgeschlossen , wenn zuvor festgelegt) .

Sie können einen oder mehrere Spaltennamen übergeben , einschließlich der zugehörigen Spalten .

Ab jetzt wird jede übergebene Spalte separat aggregiert (so dass sum (col1 + col2) nicht möglich ist , können Sie sum (col1 , col2) verwenden und dann 2 zurückgegebene Summen in Python hinzufügen)

Gibt einen einzelnen Wert als Ergebnis zurück , wenn mehrere Spalten aggregiert werden , gibt ein Dictionary mit dem Ergebnispaar column : zurück

 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)

Beispiele für die Verwendung können wie folgt aussehen

 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 () () ist die
await Book (title = " Book 1 " , year = 1920 , ranking = 3 , author = author) . save () (siehe auch : await Book = " Book 1 " , year = 1920 , ranking = 3 , author = author) .
await Book (title = " Book2 " , year = 1930 , ranking = 1 , author = author) . save ()
await Book (title = " Book 3 " , Jahr = 1923 , ranking = 5 , author = author) . save ()

assert await book . objects . max (" Jahr ") = = 1930
result = await Book . objects . max ([ " Jahr " , " Rang " ])
assert result = = dict (year = 1930 , ranking = 5) [ Bearbeiten | Quelltext bearbeiten ]

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

Assert Await hinzufügenAuthor.objects.select_ related (" Bücher ") . max (" Bücher _ _ Jahr ") = 1930
ergebnis = awaitAuthor.objects.selectBücher (max .
    [ " Bücher _ Jahr " , " Bücher _ Ranking " ]
)
assert result = = dict (books _ _ year = 1930 , books _ _ ranking = 5) Bearbeiten

eingeblendet (
    Await sehenAuthor.objects.selectBücher („ Bücher ")
    . filter (Bücher _ _ Jahr _ _ lt = 1925)
    . max (" Bücher _ Jahr ")
    == 1923
)

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 .

Anzahl Anzahl

Genau wie die count-Funktion oben , aber Sie können eine Spalte aus einem verwandten Objekt am anderen Ende der Beziehung auswählen .

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

Existiert

Genau die gleiche existenzielle Funktion wie oben , aber ermöglicht es Ihnen , Spalten aus verwandten Objekten am anderen Ende der Beziehung auszuwählen .

und

Genau wie die sum-Funktion oben , aber Sie können die Spalten eines verwandten Objekts am anderen Ende der Beziehung summieren .

Durchschnittlich

Genau das gleiche wie die oben stehende avg-Funktion , aber Sie können die Spalten eines verwandten Objekts am anderen Ende der Beziehung durchschnittlich .

Minuten .

Genau die gleiche Funktion wie die min oben , aber ermöglicht es Ihnen , die geringste Anzahl von Spalten aus einem relevanten Objekt am anderen Ende der Beziehung auszuwählen .

Das Maximum

Es ist genau das gleiche wie die oben genannte Funktion max , ermöglicht Ihnen jedoch die Auswahl der größten Spalte aus einem relevanten Objekt am anderen Ende der Beziehung .

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