Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Aggregationsfunktionen
Aggregatfunktionen in AWS Clean Rooms Spark SQL werden verwendet, um Berechnungen oder Operationen für eine Gruppe von Zeilen durchzuführen und einen einzelnen Wert zurückzugeben. Sie sind für Datenanalyse- und Zusammenfassungsaufgaben unerlässlich.
AWS Clean Rooms Spark SQL unterstützt die folgenden Aggregatfunktionen:
**Topics**
+ [Funktion ANY\$1VALUE](ANY_VALUE.md)
+ [APPROX COUNT\$1DISTINCT-Funktion](approx-count-distinct.md)
+ [Funktion „UNGEFÄHRES PERZENTIL“](approx-percentile.md)
+ [AVG Funktion](avg-function.md)
+ [Die Funktion BOOL\$1AND](BOOL_AND.md)
+ [Die Funktion BOOL\$1OR](BOOL_OR.md)
+ [CARDINALITY-Funktion](CARDINALITY.md)
+ [Funktion COLLECT\$1LIST](COLLECT_LIST.md)
+ [Funktion COLLECT\$1SET](COLLECT_SET.md)
+ [COUNTund COUNT DISTINCT Funktionen](count-function.md)
+ [Die Funktion COUNT](COUNT.md)
+ [Die Funktion MAX](MAX.md)
+ [Die Funktion MEDIAN](MEDIAN.md)
+ [Die Funktion MIN](MIN.md)
+ [PERZENTILE-Funktion](percentile.md)
+ [SKEWNESS-Funktion](SKEWNESS.md)
+ [Die Funktionen STDDEV\$1SAMP und STDDEV\$1POP](STDDEV_functions.md)
+ [SUMund SUM DISTINCT Funktionen](sum-function.md)
+ [Die Funktionen VAR\$1SAMP und VAR\$1POP](VARIANCE_functions.md)
# Funktion ANY\$1VALUE
Die Funktion ANY\$1VALUE gibt einen beliebigen Wert aus den Eingabeausdruckswerten nicht deterministisch zurück. Diese Funktion kann NULL zurückgeben, wenn der Eingabeausdruck nicht dazu führt, dass Zeilen zurückgegeben werden.
## Syntax
```
ANY_VALUE (expression[, isIgnoreNull] )
```
## Argumente
*Ausdruck *
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird. Der *Ausdruck* ist einer der folgenden Datentypen:
*isIgnoreNull*
Ein boolescher Wert, der bestimmt, ob die Funktion nur Werte zurückgeben soll, die ungleich Null sind.
## Rückgabewert
Gibt denselben Datentyp wie *expression* zurück.
## Nutzungshinweise
Wenn eine Anweisung, die die Funktion ANY\$1VALUE für eine Spalte angibt, auch einen Verweis auf eine zweite Spalte enthält, muss die zweite Spalte in einer GROUP-BY-Klausel oder in einer Aggregationsfunktion enthalten sein.
## Beispiele
Das folgende Beispiel gibt eine Instanz von any zurück, `dateid` wo der ist. `eventname` `Eagles`
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
Die Ergebnisse sehen wie folgt aus.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
Im folgenden Beispiel wird eine Instanz von any zurückgegeben`dateid`, wobei der Wert `Eagles` oder `eventname` ist`Cold War Kids`.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
Die Ergebnisse sehen wie folgt aus.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# APPROX COUNT\$1DISTINCT-Funktion
APPROX COUNT\$1DISTINCT bietet eine effiziente Methode, um die Anzahl der Einzelwerte in einer Spalte oder einem Datensatz zu schätzen.
## Syntax
```
approx_count_distinct(expr[, relativeSD])
```
## Argumente
*expr*
Der Ausdruck oder die Spalte, für die Sie die Anzahl der Einzelwerte schätzen möchten.
Dabei kann es sich um eine einzelne Spalte, einen komplexen Ausdruck oder eine Kombination von Spalten handeln.
*Verwandte D*
Ein optionaler Parameter, der die gewünschte relative Standardabweichung der Schätzung angibt.
Es handelt sich um einen Wert zwischen 0 und 1, der den maximal akzeptablen relativen Fehler der Schätzung darstellt. Ein kleinerer RelativeSD-Wert führt zu einer genaueren, aber langsameren Schätzung.
Wenn dieser Parameter nicht angegeben wird, wird ein Standardwert (normalerweise etwa 0,05 oder 5%) verwendet.
## Rückgabewert
Gibt die geschätzte Kardinalität von HyperLogLog \$1\$1 zurück. RelativeSD definiert die maximal zulässige relative Standardabweichung.
## Beispiel
Die folgende Abfrage schätzt die Anzahl der Einzelwerte in der `col1` Spalte mit einer relativen Standardabweichung von 1% (0,01).
```
SELECT approx_count_distinct(col1, 0.01)
```
Die folgende Abfrage schätzt, dass die `col1` Spalte 3 Einzelwerte enthält (die Werte 1, 2 und 3).
```
SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1)
```
# Funktion „UNGEFÄHRES PERZENTIL“
APPROX PERCENTILE wird verwendet, um den Perzentilwert eines bestimmten Ausdrucks oder einer bestimmten Spalte zu schätzen, ohne den gesamten Datensatz sortieren zu müssen. Diese Funktion ist in Szenarien nützlich, in denen Sie schnell die Verteilung eines großen Datensatzes verstehen oder auf Perzentilen basierende Metriken verfolgen müssen, ohne den Rechenaufwand für die Durchführung einer exakten Perzentilberechnung aufwenden zu müssen. Es ist jedoch wichtig, die Kompromisse zwischen Geschwindigkeit und Genauigkeit zu verstehen und die richtige Fehlertoleranz auf der Grundlage der spezifischen Anforderungen Ihres Anwendungsfalls auszuwählen.
## Syntax
```
APPROX_PERCENTILE(expr, percentile [, accuracy])
```
## Argumente
*expr*
Der Ausdruck oder die Spalte, für die Sie den Perzentilwert schätzen möchten.
Dabei kann es sich um eine einzelne Spalte, einen komplexen Ausdruck oder eine Kombination von Spalten handeln.
*percentile*
Der Perzentilwert, den Sie schätzen möchten, ausgedrückt als Wert zwischen 0 und 1.
Beispielsweise würde 0,5 dem 50. Perzentil (Median) entsprechen.
*Genauigkeit*
Ein optionaler Parameter, der die gewünschte Genauigkeit der Perzentilschätzung angibt. Es handelt sich um einen Wert zwischen 0 und 1, der den maximal akzeptablen relativen Fehler der Schätzung darstellt. Ein kleinerer `accuracy` Wert führt zu einer genaueren, aber langsameren Schätzung. Wenn dieser Parameter nicht angegeben wird, wird ein Standardwert (normalerweise etwa 0,05 oder 5%) verwendet.
## Rückgabewert
Gibt das ungefähre Perzentil der numerischen oder ANSI-Intervallspalte col zurück, das der kleinste Wert in den geordneten COL-Werten ist (sortiert vom kleinsten zum größten), sodass nicht mehr als ein Prozentsatz der COL-Werte kleiner als der Wert oder gleich diesem Wert ist.
Der Prozentwert muss zwischen 0,0 und 1,0 liegen. Der Genauigkeitsparameter (Standard: 10000) ist ein positives numerisches Literal, das die Näherungsgenauigkeit auf Kosten des Speichers steuert.
Ein höherer Genauigkeitswert führt zu einer besseren Genauigkeit. Dies `1.0/accuracy` ist der relative Fehler der Näherung.
Wenn es sich bei Prozent um eine Matrix handelt, muss jeder Wert der Prozentmatrix zwischen 0,0 und 1,0 liegen. Gibt in diesem Fall das ungefähre Perzentil-Array der Spalte col bei der angegebenen Prozentzahl zurück.
## Beispiele
Die folgende Abfrage schätzt das 95. Perzentil der `response_time` Spalte mit einem maximalen relativen Fehler von 1% (0,01).
```
SELECT APPROX_PERCENTILE(response_time, 0.95, 0.01) AS p95_response_time
FROM my_table;
```
Mit der folgenden Abfrage werden die Werte für das 50., 40. und 10. Perzentil der Spalte in der Tabelle geschätzt. `col` `tab`
```
SELECT approx_percentile(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col)
```
Mit der folgenden Abfrage wird das 50. Perzentil (Median) der Werte in der Spalte Spalte geschätzt.
```
SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col)
```
# AVG Funktion
Die AVG Funktion gibt den Durchschnitt (das arithmetische Mittel) der eingegebenen Ausdruckswerte zurück. Die AVG Funktion arbeitet mit numerischen Werten und ignoriert NULL-Werte.
## Syntax
```
AVG (column)
```
## Argumente
*column*
Die Zielspalte, in der die Funktion ausgeführt wird. Die Spalte ist einer der folgenden Datentypen:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ DOUBLE
+ FLOAT
## Datentypen
Die von der AVG Funktion unterstützten Argumenttypen sind SMALLINTINTEGER,BIGINT,DECIMAL, undDOUBLE.
Die von der AVG Funktion unterstützten Rückgabetypen sind:
+ BIGINTfür jedes Argument vom Typ Integer
+ DOUBLEfür ein Fließkomma-Argument
+ Gibt den gleichen Datentyp wie der Ausdruck für jeden anderen Argumenttyp zurück
Die Standardgenauigkeit für ein AVG Funktionsergebnis mit einem DECIMAL Argument ist 38. Die Ergebnisskala ist die gleiche wie die Skala des Arguments. Beispielsweise gibt der Wert AVG einer DEC(5,2) Spalte einen DEC(38,2) Datentyp zurück.
## Beispiel
Suchen Sie in der SALES Tabelle nach der durchschnittlichen Verkaufsmenge pro Transaktion.
```
select avg(qtysold) from sales;
```
# Die Funktion BOOL\$1AND
Die Funktion BOOL\$1AND wird für eine einzige boolesche oder Ganzzahlspalte bzw. einen einzigen booleschen oder Ganzzahlausdruck ausgeführt. Diese Funktion wendet ähnliche Logik auf die Funktionen BIT\$1AND und BIT\$1OR an. Für diese Funktion ist der Rückgabetyp ein boolescher Wert (`true` oder `false`).
Wenn alle Werte in einem Satz „true“ sind, gibt die Funktion BOOL\$1AND `true` (`t`) zurück. Wenn ein Wert „false“ ist, gibt die Funktion `false` (`f`) zurück.
## Syntax
```
BOOL_AND ( [DISTINCT | ALL] expression )
```
## Argumente
*Ausdruck *
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird. Dieser Ausdruck muss einen booleschen oder Ganzzahl-Datentyp haben. Der Rückgabewert der Funktion ist BOOLEAN.
DISTINCT \$1 ALL
Mit dem Argument DISTINCT beseitigt die Funktion alle duplizierten Werte für den angegebenen Ausdruck, bevor das Ergebnis berechnet wird. Mit dem Argument ALL behält die Funktion alle duplizierten Werte. ALL ist das Standardargument.
## Beispiele
Sie können die booleschen Funktionen auf boolesche Ausdrücke oder Ganzzahlausdrücke anwenden.
Beispielsweise gibt die folgende Abfrage Ergebnisse aus der Standardtabelle USERS in der Datenbank TICKIT zurück, die mehrere boolesche Spalten besitzt.
Die Funktion BOOL\$1AND gibt für alle fünf Zeilen `false` zurück. Nicht allen Benutzern in diesen Bundesstaaten gefällt Sport.
```
select state, bool_and(likesports) from users
group by state order by state limit 5;
state | bool_and
------+---------
AB | f
AK | f
AL | f
AZ | f
BC | f
(5 rows)
```
# Die Funktion BOOL\$1OR
Die Funktion BOOL\$1OR wird für eine einzige boolesche oder Ganzzahlspalte bzw. einen einzigen booleschen oder Ganzzahlausdruck ausgeführt. Diese Funktion wendet ähnliche Logik auf die Funktionen BIT\$1AND und BIT\$1OR an. Für diese Funktion ist der Rückgabetyp ein boolescher Wert (`true`, `false` oder `NULL`).
Wenn ein Wert in einem Satz `true` lautet, gibt die Funktion BOOL\$1OR `true` (`t`) zurück. Wenn ein Wert in einem Satz `false` lautet, gibt die Funktion `false` (`f`) zurück. NULL kann zurückgegeben werden, wenn der Wert unbekannt ist.
## Syntax
```
BOOL_OR ( [DISTINCT | ALL] expression )
```
## Argumente
*Ausdruck *
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird. Dieser Ausdruck muss einen booleschen oder Ganzzahl-Datentyp haben. Der Rückgabewert der Funktion ist BOOLEAN.
DISTINCT \$1 ALL
Mit dem Argument DISTINCT beseitigt die Funktion alle duplizierten Werte für den angegebenen Ausdruck, bevor das Ergebnis berechnet wird. Mit dem Argument ALL behält die Funktion alle duplizierten Werte. ALL ist das Standardargument.
## Beispiele
Sie können die booleschen Funktionen mit booleschen Ausdrücken oder Ganzzahlausdrücken verwenden. Beispielsweise gibt die folgende Abfrage Ergebnisse aus der Standardtabelle USERS in der Datenbank TICKIT zurück, die mehrere boolesche Spalten besitzt.
Die Funktion BOOL\$1OR gibt für alle fünf Zeilen `true` zurück. Mindestens einem Benutzer in diesen Bundesstaaten gefällt Sport.
```
select state, bool_or(likesports) from users
group by state order by state limit 5;
state | bool_or
------+--------
AB | t
AK | t
AL | t
AZ | t
BC | t
(5 rows)
```
Im folgenden Beispiel wird NULL zurückgegeben.
```
SELECT BOOL_OR(NULL = '123')
bool_or
------
NULL
```
# CARDINALITY-Funktion
*Die CARDINALITY-Funktion gibt die Größe eines ARRAY- oder MAP-Ausdrucks (expr) zurück.*
Diese Funktion ist nützlich, um die Größe oder Länge eines Arrays zu ermitteln.
## Syntax
```
cardinality(expr)
```
## Argumente
*expr*
Ein ARRAY- oder MAP-Ausdruck.
## Rückgabewert
Gibt die Größe eines Arrays oder einer Map zurück (INTEGER).
Die Funktion gibt `NULL` bei einer Null-Eingabe zurück, ob `sizeOfNull` sie auf `false` oder gesetzt `enabled` ist`true`.
Andernfalls kehrt `-1` die Funktion bei einer Null-Eingabe zurück. Mit den Standardeinstellungen kehrt die Funktion bei einer `-1` Nulleingabe zurück.
## Beispiel
Die folgende Abfrage berechnet die Kardinalität oder die Anzahl der Elemente im angegebenen Array. Das Array (`'b', 'd', 'c', 'a'`) hat 4 Elemente, also wäre die Ausgabe dieser Abfrage. `4`
```
SELECT cardinality(array('b', 'd', 'c', 'a'));
4
```
# Funktion COLLECT\$1LIST
Die Funktion COLLECT\$1LIST sammelt eine Liste von nicht eindeutigen Elementen und gibt sie zurück.
Diese Art von Funktion ist nützlich, wenn Sie mehrere Werte aus einer Reihe von Zeilen in einer einzigen Array- oder Listendatenstruktur sammeln möchten.
**Anmerkung**
Die Funktion ist nicht deterministisch, da die Reihenfolge der gesammelten Ergebnisse von der Reihenfolge der Zeilen abhängt, die nach einer Shuffle-Operation möglicherweise nicht deterministisch ist.
## Syntax
```
collect_list(expr)
```
## Argumente
*expr*
Ein Ausdruck beliebigen Typs.
## Rückgabewert
Gibt ein ARRAY des Argumenttyps zurück. Die Reihenfolge der Elemente im Array ist nicht deterministisch.
NULL-Werte sind ausgeschlossen.
Wenn DISTINCT angegeben ist, sammelt die Funktion nur eindeutige Werte und ist ein Synonym für `collect_set ` Aggregatfunktion.
## Beispiel
Die folgende Abfrage sammelt alle Werte aus der Spalte col in einer Liste. Die `VALUES` Klausel wird verwendet, um eine Inline-Tabelle mit drei Zeilen zu erstellen, wobei jede Zeile eine einzelne Spalte col mit den Werten 1, 2 und 1 hat. Die `collect_list() ` Funktion wird dann verwendet, um alle Werte aus der Spalte col in einem einzigen Array zu aggregieren. Die Ausgabe dieser SQL-Anweisung wäre das Array`[1,2,1]`, das alle Werte aus der Spalte col in der Reihenfolge enthält, in der sie in den Eingabedaten erschienen sind.
```
SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2,1]
```
# Funktion COLLECT\$1SET
Die Funktion COLLECT\$1SET sammelt eine Reihe von eindeutigen Elementen und gibt sie zurück.
Diese Funktion ist nützlich, wenn Sie alle unterschiedlichen Werte aus einer Reihe von Zeilen in einer einzigen Datenstruktur sammeln möchten, ohne Duplikate einzubeziehen.
**Anmerkung**
Die Funktion ist nicht deterministisch, da die Reihenfolge der gesammelten Ergebnisse von der Reihenfolge der Zeilen abhängt, die nach einer Shuffle-Operation möglicherweise nicht deterministisch ist.
## Syntax
```
collect_set(expr)
```
## Argumente
*expr*
Ein Ausdruck eines beliebigen Typs außer MAP.
## Rückgabewert
Gibt ein ARRAY des Argumenttyps zurück. Die Reihenfolge der Elemente im Array ist nicht deterministisch.
NULL-Werte sind ausgeschlossen.
## Beispiel
Die folgende Abfrage sammelt alle Einzelwerte aus der Spalte col in einem Satz. Die `VALUES` Klausel wird verwendet, um eine Inline-Tabelle mit drei Zeilen zu erstellen, wobei jede Zeile eine einzelne Spalte col mit den Werten 1, 2 und 1 hat. Die `collect_set()` Funktion wird dann verwendet, um alle Einzelwerte aus der Spalte col zu einem einzigen Satz zusammenzufassen. Die Ausgabe dieser SQL-Anweisung wäre der Satz`[1,2]`, der die eindeutigen Werte aus der Spalte col enthält. Der doppelte Wert 1 ist nur einmal im Ergebnis enthalten.
```
SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2]
```
# COUNTund COUNT DISTINCT Funktionen
Die COUNT Funktion zählt die durch den Ausdruck definierten Zeilen. Die COUNT DISTINCT Funktion berechnet die Anzahl der unterschiedlichen Werte, die nicht NULL sind, in einer Spalte oder einem Ausdruck. Sie entfernt alle doppelten Werte aus dem angegebenen Ausdruck, bevor die Zählung durchgeführt wird.
## Syntax
```
COUNT (DISTINCT column)
```
## Argumente
*column*
Die Zielspalte, in der die Funktion ausgeführt wird.
## Datentypen
Die COUNT Funktion und die COUNT DISTINCT Funktion unterstützen alle Argumentdatentypen.
Die COUNT DISTINCT Funktion kehrt zurückBIGINT.
## Beispiele
Zählen Sie alle Benutzer aus dem Bundesstaat Florida.
```
select count (identifier) from users where state='FL';
```
Zählen Sie alle einzigartigen Veranstaltungsorte IDs anhand der EVENT Tabelle.
```
select count (distinct venueid) as venues from event;
```
# Die Funktion COUNT
Die Funktion COUNT zählt die durch den Ausdruck definierten Zeilen.
Zu der Funktion COUNT gibt es folgende Varianten.
+ COUNT ( \$1 ) zählt alle Zeilen in der Zieltabelle, unabhängig davon, ob sie Null-Werte enthalten oder nicht.
+ COUNT ( *expression* ) berechnet die Zahl der Zeilen mit Nicht-NULL-Werten in einer spezifischen Spalte oder einem spezifischen Ausdruck.
+ COUNT ( DISTINCT *expression* ) berechnet die Zahl der unterschiedlichen Nicht-NULL-Werte in einer Spalte oder einem Ausdruck.
## Syntax
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
## Argumente
*Ausdruck *
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird. Die Funktion COUNT unterstützt alle Argumentdatentypen.
DISTINCT \$1 ALL
Mit dem Argument DISTINCT beseitigt die Funktion alle duplizierten Werte aus dem angegebenen Ausdruck, bevor die Zählung ausgeführt wird. Mit dem Argument ALL behält die Funktion alle duplizierten Werte aus dem angegebenen Ausdruck, um die Zählung auszuführen. ALL ist das Standardargument.
## Rückgabetyp
Die Funktion COUNT gibt BIGINT zurück.
## Beispiele
Zählung aller Benutzer aus dem Bundesstaat Florida:
```
select count(*) from users where state='FL';
count
-------
510
```
Zählung aller Ereignisnamen aus der EVENT-Tabelle:
```
select count(eventname) from event;
count
-------
8798
```
Zählung aller Ereignisnamen aus der EVENT-Tabelle:
```
select count(all eventname) from event;
count
-------
8798
```
Zählen Sie alle einzigartigen Veranstaltungsorte IDs aus der EVENT-Tabelle:
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
Zählung der Häufigkeit, mit der die einzelnen Verkäufer Batches von mehr als vier Tickets zum Verkauf aufgelistet haben; Gruppierung der Ergebnisse nach Verkäufer-ID:
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
# Die Funktion MAX
Die Funktion MAX gibt den maximal zulässigen Wert in einem Satz von Zeilen zurück. DISTINCT oder ALL könnten zwar verwendet werden, wirken sich jedoch nicht auf das Ergebnis aus.
## Syntax
```
MAX ( [ DISTINCT | ALL ] expression )
```
## Argumente
*Ausdruck *
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird. Der *Ausdruck* ist ein beliebiger numerischer Datentyp.
DISTINCT \$1 ALL
Mit dem Argument DISTINCT beseitigt die Funktion alle duplizierten Werte aus dem angegebenen Ausdruck, bevor der maximal zulässige Wert berechnet wird. Mit dem Argument ALL behält die Funktion alle duplizierten Werte aus dem angegebenen Ausdruck, um den maximal zulässigen Wert zu berechnen. ALL ist das Standardargument.
## Datentypen
Gibt denselben Datentyp wie *expression* zurück.
## Beispiele
Suche des höchsten Preises, der in allen Verkäufen gezahlt wurde:
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
Suche des höchsten Preises pro Ticket, der in allen Verkäufen gezahlt wurde:
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# Die Funktion MEDIAN
## Syntax
```
MEDIAN ( median_expression )
```
## Argumente
*median\$1expression*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
# Die Funktion MIN
Die Funktion MIN gibt den Mindestwert in einem Satz von Zeilen zurück. DISTINCT oder ALL könnten zwar verwendet werden, wirken sich jedoch nicht auf das Ergebnis aus.
## Syntax
```
MIN ( [ DISTINCT | ALL ] expression )
```
## Argumente
*Ausdruck *
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird. Der *Ausdruck* ist ein beliebiger numerischer Datentyp.
DISTINCT \$1 ALL
Mit dem Argument DISTINCT beseitigt die Funktion alle duplizierten Werte aus dem angegebenen Ausdruck, bevor der Mindestwert berechnet wird. Mit dem Argument ALL behält die Funktion alle duplizierten Werte aus dem angegebenen Ausdruck, um den Mindestwert zu berechnen. ALL ist das Standardargument.
## Datentypen
Gibt denselben Datentyp wie *expression* zurück.
## Beispiele
Suche des niedrigsten Preises, der in allen Verkäufen gezahlt wurde:
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
Suche des niedrigsten Preises pro Ticket, der in allen Verkäufen gezahlt wurde:
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# PERZENTILE-Funktion
Die PERCENTILE-Funktion wird verwendet, um den exakten Perzentilwert zu berechnen, indem zuerst die Werte in der Spalte sortiert und dann der Wert am angegebenen Wert ermittelt wird. `col` `percentage`
Die PERZENTILE-Funktion ist nützlich, wenn Sie den exakten Perzentilwert berechnen müssen und der Rechenaufwand für Ihren Anwendungsfall akzeptabel ist. Sie liefert genauere Ergebnisse als die APPROX\$1PERCENTILE-Funktion, ist aber möglicherweise langsamer, insbesondere bei großen Datensätzen.
Im Gegensatz dazu ist die Funktion APPROX\$1PERCENTILE eine effizientere Alternative, da sie eine Schätzung des Perzentilwerts mit einer bestimmten Fehlertoleranz liefern kann. Dadurch eignet sie sich besser für Szenarien, in denen Geschwindigkeit eine höhere Priorität als absolute Genauigkeit hat.
## Syntax
```
percentile(col, percentage [, frequency])
```
## Argumente
*Spalte*
Der Ausdruck oder die Spalte, für die Sie den Perzentilwert berechnen möchten.
*Prozentsatz*
Der Perzentilwert, den Sie berechnen möchten, ausgedrückt als Wert zwischen 0 und 1.
Beispielsweise würde 0,5 dem 50. Perzentil (Median) entsprechen.
*Frequenz*
Ein optionaler Parameter, der die Häufigkeit oder Gewichtung der einzelnen Werte in der `col` Spalte angibt. Falls angegeben, berechnet die Funktion das Perzentil auf der Grundlage der Häufigkeit der einzelnen Werte.
## Rückgabewert
Gibt den exakten Perzentilwert der numerischen oder ANSI-Intervallspalte col zum angegebenen Prozentsatz zurück.
Der Prozentwert muss zwischen 0,0 und 1,0 liegen.
Der Wert der Frequenz sollte ein positives Integral sein
## Beispiel
Die folgende Abfrage findet den Wert, der größer oder gleich 30% der Werte in der `col` Spalte ist. Da die Werte 0 und 10 sind, ist das 30. Perzentil 3,0, weil es der Wert ist, der größer oder gleich 30% der Daten ist.
```
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
3.0
```
# SKEWNESS-Funktion
Die Funktion SKEWNESS gibt den Wert der Schiefe zurück, der anhand der Werte einer Gruppe berechnet wurde.
Die Schiefe ist ein statistisches Maß, das die Asymmetrie oder den Mangel an Symmetrie in einem Datensatz beschreibt. Sie liefert Informationen über die Form der Datenverteilung.
Diese Funktion kann nützlich sein, um die statistischen Eigenschaften eines Datensatzes zu verstehen und als Grundlage für weitere Analysen oder Entscheidungen zu dienen.
## Syntax
```
skewness(expr)
```
## Argumente
*expr*
Ein Ausdruck, der zu einer Zahl ausgewertet wird.
## Rückgabewert
Gibt DOUBLE zurück.
Wenn DISTINCT angegeben ist, arbeitet die Funktion nur mit einem eindeutigen Satz von *Ausdruckwerten*.
## Beispiele
Die folgende Abfrage berechnet die Schiefe der Werte in der Spalte. `col` In diesem Beispiel wird die `VALUES` Klausel verwendet, um eine Inline-Tabelle mit vier Zeilen zu erstellen, wobei jede Zeile eine einzelne Spalte `col` mit den Werten -10, -20, 100 und 1000 enthält. Die `skewness()` Funktion wird dann verwendet, um die Schiefe der Werte in der `col` Spalte zu berechnen. Das Ergebnis, 1.1135657469022011, stellt den Grad und die Richtung der Schiefe in den Daten dar. Ein positiver Wert für die Schiefe gibt an, dass die Daten nach rechts geneigt sind, sodass sich der Großteil der Werte auf der linken Seite der Verteilung konzentriert. Ein negativer Wert für die Schiefe gibt an, dass die Daten nach links geneigt sind und sich der Großteil der Werte auf der rechten Seite der Verteilung konzentriert.
```
SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
1.1135657469022011
```
Die folgende Abfrage berechnet die Schiefe der Werte in der Spalte col. Ähnlich wie im vorherigen Beispiel wird die `VALUES` Klausel verwendet, um eine Inline-Tabelle mit vier Zeilen zu erstellen, wobei jede Zeile eine einzelne Spalte `col` mit den Werten -1000, -100, 10 und 20 enthält. Die `skewness()` Funktion wird dann verwendet, um die Schiefe der Werte in der Spalte zu berechnen. `col` Das Ergebnis, -1,135657469022011, stellt den Grad und die Richtung der Schiefe in den Daten dar. In diesem Fall gibt der negative Wert für die Schiefe an, dass die Daten nach links geneigt sind, sodass sich der Großteil der Werte auf der rechten Seite der Verteilung konzentriert.
```
SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
-1.1135657469022011
```
# Die Funktionen STDDEV\$1SAMP und STDDEV\$1POP
Die Funktionen STDDEV\$1SAMP und STDDEV\$1POP geben die Stichproben- und Populationsstandardabweichungen eines Satzes numerischer Werte (integer, decimal oder floating-point) zurück. Das Ergebnis der Funktion STDDEV\$1SAMP entspricht der Quadratwurzel der Stichprobenabweichung desselben Satzes von Werten.
STDDEV\$1SAMP und STDDEV sind Synonyme für dieselbe Funktion.
## Syntax
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression) STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
Der Ausdruck muss einen numerischen Datentyp haben. Unabhängig vom Datentyp des Ausdrucks ist der Rückgabewert dieser Funktion eine DOUBLE PRECISION-Zahl.
**Anmerkung**
Die Standardabweichung wird mittels Gleitkommaarithmetik berechnet. Dies kann zu einer leichten Ungenauigkeit führen.
## Nutzungshinweise
Wenn die Stichprobenstandardabweichung (STDDEV oder STDDEV\$1SAMP) für einen Ausdruck berechnet wird, der aus einem einzigen Wert besteht, ist das Ergebnis der Funktion NULL und nicht 0.
## Beispiele
Die folgende Abfrage gibt den Durchschnitt der Werte in der Spalte VENUESEATS der Tabelle VENUE zurück, gefolgt von der Stichprobenstandardabweichung und der Populationsstandardabweichung desselben Satzes von Werten. VENUESEATS ist eine INTEGER-Spalte. Die Ergebnisskala ist auf 2 Ziffern reduziert.
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
Die folgende Abfrage gibt die Stichprobenstandardabweichung für die Spalte COMMISSION in der Tabelle SALES zurück. COMMISSION ist eine DECIMAL-Spalte. Die Ergebnisskala ist auf 10 Ziffern reduziert.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
Die folgende Abfrage gibt die Stichprobenstandardabweichung für die Spalte COMMISSION als Ganzzahl aus.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
Die folgende Abfrage gibt sowohl die Stichprobenstandardabweichung als auch die Quadratwurzel der Stichprobenabweichung für die Spalte COMMISSION zurück. Die Ergebnisse dieser Berechnungen sind identisch.
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# SUMund SUM DISTINCT Funktionen
Die SUM Funktion gibt die Summe der Eingabespalten- oder Ausdruckswerte zurück. Die SUM Funktion arbeitet mit numerischen Werten und ignoriert NULL Werte.
Die SUM DISTINCT Funktion entfernt alle doppelten Werte aus dem angegebenen Ausdruck, bevor die Summe berechnet wird.
## Syntax
```
SUM (DISTINCT column )
```
## Argumente
*column*
Die Zielspalte, in der die Funktion ausgeführt wird. Bei der Spalte handelt es sich um beliebige numerische Datentypen.
## Beispiele
Ermitteln Sie die Summe aller gezahlten Provisionen anhand der SALES Tabelle.
```
select sum(commission) from sales
```
Ermitteln Sie die Summe aller einzelnen gezahlten Provisionen aus der SALES Tabelle.
```
select sum (distinct (commission)) from sales
```
# Die Funktionen VAR\$1SAMP und VAR\$1POP
Die Funktionen VAR\$1SAMP und VAR\$1POP geben die Stichproben- und Populationsabweichung eines Satzes numerischer Werte (integer, decimal oder floating-point) zurück. Das Ergebnis der Funktion VAR\$1SAMP entspricht der Quadratwurzel der Stichprobenstandardabweichung desselben Satzes von Werten.
VAR\$1SAMP und VARIANCE sind Synonyme für dieselbe Funktion.
## Syntax
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
Der Ausdruck muss einen Ganzzahl-, Dezimal- oder Gleitkommadatentyp haben. Unabhängig vom Datentyp des Ausdrucks ist der Rückgabewert dieser Funktion eine DOUBLE PRECISION-Zahl.
**Anmerkung**
Die Ergebnisse dieser Funktionen sind je nach Data Warehouse-Cluster verschieden, abhängig von der Konfiguration des jeweiligen Clusters.
## Nutzungshinweise
Wenn die Stichprobenabweichung (VARIANCE oder VAR\$1SAMP) für einen Ausdruck berechnet wird, der aus einem einzigen Wert besteht, ist das Ergebnis der Funktion NULL und nicht 0.
## Beispiele
Die folgende Abfrage gibt die gerundete Stichproben- und Populationsabweichung für die Spalte NUMTICKETS in der Tabelle LISTING zurück.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
Die folgende Abfrage führt dieselben Berechnungen aus, gibt die Ergebnisse jedoch als Dezimalwerte aus.
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```