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.

# Mathematische Funktionen
<a name="Math_functions-spark"></a>

In diesem Abschnitt werden die mathematischen Operatoren und Funktionen beschrieben, die in AWS Clean Rooms Spark SQL unterstützt werden. 

**Topics**
+ [Symbole für mathematische Operatoren](OPERATOR_SYMBOLS.md)
+ [Funktion ABS](ABS.md)
+ [Die Funktion ACOS](ACOS.md)
+ [Die Funktion ASIN](ASIN.md)
+ [Die Funktion ATAN](ATAN.md)
+ [ATAN2 Funktion](ATAN2.md)
+ [Die Funktion CBRT](CBRT.md)
+ [Die Funktion CEILING (oder CEIL)](CEILING_FLOOR.md)
+ [Die Funktion COS](COS.md)
+ [Die Funktion COT](COT.md)
+ [Die Funktion DEGREES](DEGREES.md)
+ [DIV-Funktion](DIV.md)
+ [Die Funktion EXP](EXP.md)
+ [Die Funktion FLOOR](FLOOR.md)
+ [Die Funktion LN](LN.md)
+ [Die Funktion LOG](LOG.md)
+ [Die Funktion MOD](MOD.md)
+ [Die Funktion PI](PI.md)
+ [Die Funktion POWER](POWER.md)
+ [Die Funktion RADIANS](RADIANS.md)
+ [RAND-Funktion](RAND.md)
+ [Die Funktion RANDOM](RANDOM.md)
+ [Die Funktion ROUND](ROUND.md)
+ [Die Funktion SIGN](SIGN.md)
+ [Die Funktion SIN](SIN.md)
+ [Die Funktion SQRT](SQRT.md)
+ [Die Funktion TRUNC](TRUNC.md)

# Symbole für mathematische Operatoren
<a name="OPERATOR_SYMBOLS"></a>

 In der folgenden Tabelle werden die unterstützten mathematischen Operatoren aufgeführt. 

## Unterstützte Operatoren
<a name="OPERATOR_SYMBOLS-supported-operators"></a>

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/clean-rooms/latest/sql-reference/OPERATOR_SYMBOLS.html)

## Beispiele
<a name="OPERATOR_SYMBOLS-examples"></a>

Berechnet die gezahlte Provision zuzüglich einer Bearbeitungsgebühr von 2,00\$1 für eine bestimmte Transaktion: 

```
select commission, (commission + 2.00) as comm
from sales where salesid=10000;

commission | comm
-----------+-------
28.05      | 30.05
(1 row)
```

Berechnet 20 Prozent des Verkaufspreises für eine bestimmte Transaktion: 

```
select pricepaid, (pricepaid * .20) as twentypct
from sales where salesid=10000;

pricepaid | twentypct
----------+-----------
187.00    |    37.400
(1 row)
```

Voraussichtliche Ticketverkäufe auf der Basis eines kontinuierlichen Wachstumsmusters. In diesem Beispiel gibt die Unterabfrage die Anzahl der Tickets zurück, die 2008 verkauft wurden. Dieses Ergebnis wird exponentiell mit einer kontinuierlichen Wachstumsrate von 5 Prozent über einen Zeitraum von 10 Jahren multipliziert. 

```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid and year=2008)
^ ((5::float/100)*10) as qty10years;

qty10years
------------------
587.664019657491
(1 row)
```

Ermitteln Sie den gezahlten Gesamtpreis und die Provision für Verkäufe mit einer Datum-ID, die größer oder gleich 2.000 ist. Anschließend wird die Gesamtprovision vom gezahlten Gesamtpreis abgezogen. 

```
select sum (pricepaid) as sum_price, dateid,
sum (commission) as sum_comm, (sum (pricepaid) - sum (commission)) as value
from sales where dateid >= 2000
group by dateid order by dateid limit 10;

 sum_price | dateid | sum_comm |   value
-----------+--------+----------+-----------
 364445.00 |   2044 | 54666.75 | 309778.25
 349344.00 |   2112 | 52401.60 | 296942.40
 343756.00 |   2124 | 51563.40 | 292192.60
 378595.00 |   2116 | 56789.25 | 321805.75
 328725.00 |   2080 | 49308.75 | 279416.25
 349554.00 |   2028 | 52433.10 | 297120.90
 249207.00 |   2164 | 37381.05 | 211825.95
 285202.00 |   2064 | 42780.30 | 242421.70
 320945.00 |   2012 | 48141.75 | 272803.25
 321096.00 |   2016 | 48164.40 | 272931.60
(10 rows)
```

# Funktion ABS
<a name="ABS"></a>

 ABS berechnet den absoluten Wert einer Zahl, wobei diese Zahl ein Literal oder ein Ausdruck sein kann, der zu einer Zahl ausgewertet wird. 

## Syntax
<a name="ABS-synopsis"></a>

```
ABS (number)
```

## Argumente
<a name="ABS-arguments"></a>

 *number (Zahl*   
Zahl oder Ausdruck, der zu einer Zahl ausgewertet wird. Dabei kann es sich um den Typ SMALLINT, INTEGER, BIGINT FLOAT4, DECIMAL oder FLOAT8 handeln.

## Rückgabetyp
<a name="ABS-return-type"></a>

ABS gibt denselben Datentyp wie sein Argument zurück. 

## Beispiele
<a name="ABS-examples"></a>

Berechnet den absoluten Wert von -38: 

```
select abs (-38);
abs
-------
38
(1 row)
```

Berechnet den absoluten Wert von (14 - 76): 

```
select abs (14-76);
abs
-------
62
(1 row)
```

# Die Funktion ACOS
<a name="ACOS"></a>

ACOS ist eine trigonometrische Funktion, die den Arcuscosinus einer Zahl zurückgibt. Der Rückgabewert wird in Radianten ausgedrückt und liegt zwischen `0` und `PI`.

## Syntax
<a name="ACOS-synopsis"></a>

```
ACOS(number)
```

## Argumente
<a name="ACOS-arguments"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="ACOS-return-type"></a>

`DOUBLE PRECISION`

## Beispiele
<a name="ACOS-examples"></a>

Verwenden Sie das folgende Beispiel, um den Arcuscosinus von `-1` zurückzugeben. 

```
SELECT ACOS(-1);

+-------------------+
|       acos        |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Die Funktion ASIN
<a name="ASIN"></a>

ASIN ist eine trigonometrische Funktion, die den Arcussinus einer Zahl zurückgibt. Der Rückgabewert wird in Radianten ausgedrückt und liegt zwischen `PI/2` und `-PI/2`. 

## Syntax
<a name="ASIN-synopsis"></a>

```
ASIN(number)
```

## Argumente
<a name="ASIN-argument"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="ASIN-return-type"></a>

`DOUBLE PRECISION`

## Beispiele
<a name="ASIN-examples"></a>

Verwenden Sie das folgende Beispiel, um den Arcussinus von `1` zurückzugeben. 

```
SELECT ASIN(1) AS halfpi;

+--------------------+
|       halfpi       |
+--------------------+
| 1.5707963267948966 |
+--------------------+
```

# Die Funktion ATAN
<a name="ATAN"></a>

ATAN ist eine trigonometrische Funktion, die den Arcustangens einer Zahl zurückgibt. Der Rückgabewert wird in Radianten ausgedrückt und liegt zwischen `-PI` und `PI`.

## Syntax
<a name="ATAN-synopsis"></a>

```
ATAN(number)
```

## Argumente
<a name="ATAN-argument"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="ATAN-return-type"></a>

`DOUBLE PRECISION`

## Beispiele
<a name="ATAN-examples"></a>

Verwenden Sie das folgende Beispiel, um den Arcustangens von `1` zurückzugeben und mit 4 multipliziert.

```
SELECT ATAN(1) * 4 AS pi;
            
+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# ATAN2 Funktion
<a name="ATAN2"></a>

ATAN2 ist eine trigonometrische Funktion, die den Arkustangens einer Zahl geteilt durch eine andere Zahl zurückgibt. Der Rückgabewert wird in Radianten ausgedrückt und liegt zwischen `PI/2` und `-PI/2`. 

## Syntax
<a name="ATAN2-synopsis"></a>

```
ATAN2(number1, number2)
```

## Argumente
<a name="ATAN2-arguments"></a>

 *number1*   
Eine `DOUBLE PRECISION`-Zahl. 

 *number2*   
Eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="ATAN2-return-type"></a>

`DOUBLE PRECISION`

## Beispiele
<a name="ATAN2-examples"></a>

Verwenden Sie das folgende Beispiel, um den Arcustangens von `2/2` zurückzugeben und mit 4 multipliziert. 

```
SELECT ATAN2(2,2) * 4 AS PI;

+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Die Funktion CBRT
<a name="CBRT"></a>

 Die CBRT-Funktion ist eine mathematische Funktion, die die Kubikwurzel einer Zahl berechnet. 

## Syntax
<a name="CBRT-synopsis"></a>

```
CBRT (number)
```

## Argument
<a name="CBRT-argument"></a>

CBRT hat eine DOUBLE PRECISION-Zahl als Argument. 

## Rückgabetyp
<a name="CBRT-return-type"></a>

CBRT gibt eine DOUBLE PRECISION-Zahl zurück. 

## Beispiele
<a name="CBRT-examples"></a>

Berechnet die Kubikwurzel der Provision, die für eine bestimmte Transaktion gezahlt wurde: 

```
select cbrt(commission) from sales where salesid=10000;

cbrt
------------------
3.03839539048843
(1 row)
```

# Die Funktion CEILING (oder CEIL)
<a name="CEILING_FLOOR"></a>

Die CEILING- oder CEIL-Funktion wird verwendet, um eine Zahl auf die nächste ganze Zahl aufzurunden. (Die [Die Funktion FLOOR](FLOOR.md) rundet eine Zahl auf die nächste ganze Zahl ab.) 

## Syntax
<a name="CEILING_FLOOR-synopsis"></a>

```
CEIL | CEILING(number)
```

## Argumente
<a name="CEILING_FLOOR-arguments"></a>

 *number (Zahl*   
Die Zahl oder der Ausdruck, der zu einer Zahl ausgewertet wird. Dabei kann es sich um den Typ SMALLINT, INTEGER, BIGINT FLOAT4, DECIMAL oder handeln. FLOAT8 

## Rückgabetyp
<a name="CEILING_FLOOR-return-type"></a>

CEILING und CEIL geben denselben Datentyp wie ihr Argument zurück. 

## Beispiel
<a name="CEILING_FLOOR-example"></a>

Berechnet die Decke der Provision, die für eine bestimmte Verkaufstransaktion gezahlt wird: 

```
select ceiling(commission) from sales
where salesid=10000;

ceiling
---------
29
(1 row)
```

# Die Funktion COS
<a name="COS"></a>

COS ist eine trigonometrische Funktion, die den Cosinus einer Zahl zurückgibt. Der Rückgabewert wird in Radianten ausgedrückt und liegt zwischen `-1` und `1`, jeweils einschließlich. 

## Syntax
<a name="COS-synopsis"></a>

```
COS(double_precision)
```

## Argument
<a name="COS-argument"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine Doppelpräzisionszahl. 

## Rückgabetyp
<a name="COS-return-type"></a>

Die COS-Funktion gibt eine Doppelpräzisionszahl zurück. 

## Beispiele
<a name="COS-examples"></a>

Im folgenden Beispiel wird der Cosinus von 0 zurückgegeben: 

```
select cos(0);
cos
-----
1
(1 row)
```

Im folgenden Beispiel wird der Cosinus von PI zurückgegeben: 

```
select cos(pi());
cos
-----
-1
(1 row)
```

# Die Funktion COT
<a name="COT"></a>

COT ist eine trigonometrische Funktion, die den Kotangens einer Zahl zurückgibt. Der Eingabeparameter darf nicht null sein. 

## Syntax
<a name="COT-synopsis"></a>

```
COT(number)
```

## Argument
<a name="COT-argument"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="COT-return-type"></a>

`DOUBLE PRECISION`

## Beispiele
<a name="COT-examples"></a>

Verwenden Sie das folgende Beispiel, um den Kotangens von 1 zurückzugeben. 

```
SELECT COT(1);

+--------------------+
|        cot         |
+--------------------+
| 0.6420926159343306 |
+--------------------+
```

# Die Funktion DEGREES
<a name="DEGREES"></a>

Konvertiert einen Winkel in Radianten in die Entsprechung in Grad. 

## Syntax
<a name="DEGREES-synopsis"></a>

```
DEGREES(number)
```

## Argument
<a name="DEGREES-argument"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="DEGREES-return-type"></a>

`DOUBLE PRECISION`

## Beispiel
<a name="DEGREES-examples"></a>

Verwenden Sie das folgende Beispiel, um die Entsprechung in Grad des Radianten 0,5 zurückzugeben. 

```
SELECT DEGREES(.5);

+-------------------+
|      degrees      |
+-------------------+
| 28.64788975654116 |
+-------------------+
```

Verwenden Sie das folgende Beispiel, um PI-Radianten in Grad zu konvertieren. 

```
SELECT DEGREES(pi());

+---------+
| degrees |
+---------+
|     180 |
+---------+
```

# DIV-Funktion
<a name="DIV"></a>

Der DIV-Operator gibt den integralen Teil der Division der Dividende durch den Divisor zurück. 

## Syntax
<a name="DIV-syntax"></a>

```
dividend div divisor
```

## Argumente
<a name="DIV-arguments"></a>

 *Dividende*   
Ein Ausdruck, der zu einer Zahl oder einem Intervall ausgewertet wird.

*Divisor*  
Ein passender Intervalltyp, wenn `dividend` es sich um ein Intervall handelt, andernfalls um eine Zahl.

## Rückgabetyp
<a name="DIV-returns"></a>

`BIGINT`

## Beispiele
<a name="DIV-examples"></a>

Im folgenden Beispiel werden zwei Spalten aus der Eichhörnchen-Tabelle ausgewählt: die `id` Spalte, die den eindeutigen Bezeichner für jedes Eichhörnchen enthält, und eine `calculated` Spalte`age div 2`, die die ganzzahlige Division der Altersspalte durch 2 darstellt. `age div 2`Bei der Berechnung wird die `age` Spalte durch eine Ganzzahl dividiert, wodurch das Alter auf die nächste gerade Ganzzahl abgerundet wird. Wenn die `age` Spalte beispielsweise Werte wie 3, 5, 7 und 10 enthält, würde die `age div 2` Spalte jeweils die Werte 1, 2, 3 und 5 enthalten. 

```
SELECT id, age div 2 FROM squirrels
```

Diese Abfrage kann in Szenarien nützlich sein, in denen Sie Daten nach Altersbereichen gruppieren oder analysieren müssen und Sie die Alterswerte vereinfachen möchten, indem Sie sie auf die nächste gerade Ganzzahl abrunden. Die resultierende Ausgabe würde für jedes Eichhörnchen in der Tabelle das Alter `id` und das `squirrels` Alter geteilt durch 2 ergeben. 

# Die Funktion EXP
<a name="EXP"></a>

Die EXP-Funktion implementiert die Exponentialfunktion für einen numerischen Ausdruck, oder die Basis des natürlichen Logarithmus, `e`, potenziert mit dem Ausdruck. Die EXP-Funktion ist die Umkehrung von [Die Funktion LN](LN.md). 

## Syntax
<a name="EXP-synopsis"></a>

```
EXP (expression)
```

## Argument
<a name="EXP-argument"></a>

 *expression*   
Der Ausdruck muss den Datentyp INTEGER, DECIMAL oder DOUBLE PRECISION haben. 

## Rückgabetyp
<a name="EXP-return-type"></a>

EXP gibt eine DOUBLE PRECISION-Zahl zurück. 

## Beispiel
<a name="EXP-example"></a>

Die EXP-Funktion wird verwendet, um Ticketverkäufe auf der Basis eines kontinuierlichen Wachstumsmusters zu prognostizieren. In diesem Beispiel gibt die Unterabfrage die Anzahl der Tickets zurück, die 2008 verkauft wurden. Dieses Ergebnis wird mit dem Ergebnis der EXP-Funktion multipliziert, das eine kontinuierliche Wachstumsrate von 7 % über 10 Jahre angibt. 

```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid
and year=2008) * exp((7::float/100)*10) qty2018;

qty2018
------------------
695447.483772222
(1 row)
```

# Die Funktion FLOOR
<a name="FLOOR"></a>

Die FLOOR-Funktion rundet eine Zahl auf die nächste ganze Zahl ab. 

## Syntax
<a name="FLOOR-synopsis"></a>

```
FLOOR (number)
```

## Argument
<a name="FLOOR-argument"></a>

 *number (Zahl*   
Die Zahl oder der Ausdruck, der zu einer Zahl ausgewertet wird. Dabei kann es sich um den Typ SMALLINT, INTEGER, BIGINT FLOAT4, DECIMAL oder handeln. FLOAT8 

## Rückgabetyp
<a name="FLOOR-return-type"></a>

FLOOR gibt denselben Datentyp wie sein Argument zurück. 

## Beispiel
<a name="FLOOR-example"></a>

Das Beispiel zeigt den Wert der Provision, die für eine bestimmte Verkaufstransaktion vor und nach Verwendung der FLOOR-Funktion bezahlt wurde. 

```
select commission from sales
where salesid=10000;

floor
-------
28.05
(1 row)

select floor(commission) from sales
where salesid=10000;

floor
-------
28
(1 row)
```

# Die Funktion LN
<a name="LN"></a>

Die LN-Funktion gibt den natürlichen Logarithmus des Eingabeparameters zurück. 

## Syntax
<a name="LN-synopsis"></a>

```
LN(expression)
```

## Argument
<a name="LN-argument"></a>

 *expression*   
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.   
Diese Funktion gibt für einige Datentypen einen Fehler zurück, wenn der Ausdruck auf eine AWS Clean Rooms vom Benutzer erstellte Tabelle oder eine AWS Clean Rooms STL- oder STV-Systemtabelle verweist. 
Ausdrücke mit den folgenden Datentypen führen zu einem Fehler, wenn sie eine benutzererstellte oder eine Systemtabelle referenzieren.  
+ BOOLEAN 
+ CHAR 
+ DATUM 
+ DECIMAL oder NUMERIC 
+ TIMESTAMP 
+ VARCHAR 
Ausdrücke mit den folgenden Datentypen werden für benutzererstellte und STL- oder STV-Systemtabellen erfolgreich ausgeführt:   
+ BIGINT 
+ DOUBLE PRECISION 
+ INTEGER 
+ REAL 
+ SMALLINT 

## Rückgabetyp
<a name="LN-return-type"></a>

Die LN-Funktion gibt denselben Typ wie der Ausdruck zurück. 

## Beispiel
<a name="LN-example"></a>

Im folgenden Beispiel wird der natürliche Logarithmus bzw. Basis-e-Logarithmus der Zahl 2,718281828 zurückgegeben: 

```
select ln(2.718281828);
ln
--------------------
0.9999999998311267
(1 row)
```

Beachten Sie, dass die Antwort beinahe gleich 1 ist. 

In diesem Beispiel wird der natürliche Logarithmus der Werte in der Spalte USERID in der Tabelle USERS zurückgegeben: 

```
select username, ln(userid) from users order by userid limit 10;

 username |        ln
----------+-------------------
 JSG99FHE |                 0
 PGL08LJI | 0.693147180559945
 IFT66TXU |  1.09861228866811
 XDZ38RDD |  1.38629436111989
 AEB55QTM |   1.6094379124341
 NDQ15VBM |  1.79175946922805
 OWY35QYB |  1.94591014905531
 AZG78YIP |  2.07944154167984
 MSD36KVR |  2.19722457733622
 WKW41AIW |  2.30258509299405
(10 rows)
```

# Die Funktion LOG
<a name="LOG"></a>

Gibt den Logarithmus von mit zurück. `expr` `base`

## Syntax
<a name="LOG-synopsis"></a>

```
LOG(base, expr)
```

## Argument
<a name="LOG-argument"></a>

 *expr*   
Der Ausdruck muss einen Ganzzahl-, Dezimal- oder Gleitkommadatentyp haben. 

 *base*   
Die Basis für die Logarithmusberechnung. Muss eine positive Zahl (ungleich 1) vom Datentyp doppelter Genauigkeit sein. 

## Rückgabetyp
<a name="LOG-return-type"></a>

Die LOG-Funktion gibt eine Doppelpräzisionszahl zurück. 

## Beispiel
<a name="LOG-example"></a>

Im folgenden Beispiel wird der Logarithmus der Zahl 100 zur Basis 10 zurückgegeben: 

```
select log(10, 100);
--------
2
(1 row)
```

# Die Funktion MOD
<a name="MOD"></a>

Gibt den Rest von zwei Zahlen zurück, auch bekannt als *Modulo*-Operation. Um das Ergebnis zu berechnen, wird der erste Parameter durch den zweiten geteilt.

## Syntax
<a name="MOD-synopsis"></a>

```
MOD(number1, number2)
```

## Argumente
<a name="MOD-arguments"></a>

 *number1*   
Der erste Eingabeparameter ist eine INTEGER-, SMALLINT-, BIGINT- oder DECIMAL-Zahl. Wenn es sich bei einem der beiden Parameter um einen Parameter des Typs DECIMAL handelt, muss es sich beim anderen Parameter ebenfalls um einen Parameter des Typs DECIMAL handeln. Wenn es sich bei einem der beiden Parameter um einen Parameter des Typs INTEGER handelt, kann es sich beim anderen Parameter um einen Parameter des Typs INTEGER, SMALLINT oder BIGINT handeln. Beide Parameter können auch den Typ SMALLINT oder BIGINT haben. Wenn ein Parameter jedoch den Typ BIGINT hat, kann der andere Parameter nicht den Typ SMALLINT haben. 

 *number2*   
Der zweite Parameter ist eine INTEGER-, SMALLINT-, BIGINT- oder DECIMAL-Zahl. Die gleichen Datentypregeln gelten für *number2* wie für *number1*. 

## Rückgabetyp
<a name="MOD-return-type"></a>

Gültige Rückgabetypen sind DECIMAL, INT, SMALLINT und BIGINT. Der Rückgabetyp der MOD-Funktion ist der gleiche numerische Typ wie die Eingabeparameter, wenn beide Eingabeparameter denselben Datentyp haben. Wenn es sich bei einem der Eingabeparameter um einen INTEGER handelt, ist der Rückgabetyp auch ein INTEGER. 

## Nutzungshinweise
<a name="MOD-usage-notes"></a>

Sie können *%* als Modulo-Operator verwenden.

## Beispiele
<a name="MOD-example"></a>

Im folgenden Beispiel wird der Rest einer Division von zwei Zahlen zurückgegeben:

```
SELECT MOD(10, 4);
               
 mod
------
 2
```

Im folgenden Beispiel wird ein Dezimalergebnis zurückgegeben:

```
SELECT MOD(10.5, 4);
               
 mod
------
 2.5
```

Sie können Parameterwerte umwandeln:

```
SELECT MOD(CAST(16.4 as integer), 5);
               
 mod
------
 1
```

Überprüfen Sie, ob der erste Parameter gerade ist, indem Sie ihn durch 2 teilen:

```
SELECT mod(5,2) = 0 as is_even;
               
 is_even
--------
 false
```

Sie können *%* als Modulo-Operator verwenden:

```
SELECT 11 % 4 as remainder;
               
 remainder
-----------
 3
```

Das folgende Beispiel gibt Informationen zu Kategorien mit ungeraden Nummern in der Tabelle CATEGORY zurück: 

```
select catid, catname
from category
where mod(catid,2)=1
order by 1,2;

 catid |  catname
-------+-----------
     1 | MLB
     3 | NFL
     5 | MLS
     7 | Plays
     9 | Pop
    11 | Classical

(6 rows)
```

# Die Funktion PI
<a name="PI"></a>

Die PI-Funktion gibt den Wert von Pi auf 14 Dezimalstellen zurück. 

## Syntax
<a name="PI-synopsis"></a>

```
PI()
```

## Rückgabetyp
<a name="PI-return-type"></a>

`DOUBLE PRECISION`

## Beispiele
<a name="PI-examples"></a>

Verwenden Sie das folgende Beispiel, um den Wert von Pi zurückzugeben.

```
SELECT PI();

+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Die Funktion POWER
<a name="POWER"></a>

 Die POWER-Funktion ist eine Exponentialfunktion, die einen numerischen Ausdruck mit der Potenz eines zweiten numerischen Ausdrucks potenziert. Beispielsweise wird 2 in der dritten Potenz als `POWER(2,3)` berechnet. Das Ergebnis ist `8`. 

## Syntax
<a name="POWER-synopsis"></a>

```
{POWER(expression1, expression2)
```

## Argumente
<a name="POWER-arguments"></a>

 *expression1*   
Der numerische Ausdruck, der potenziert werden soll. Muss ein `INTEGER`-, `DECIMAL`- oder `FLOAT`-Datentyp sein. 

 *expression2*   
Potenz, mit der *expression1*potenziert werden soll. Muss ein `INTEGER`-, `DECIMAL`- oder `FLOAT`-Datentyp sein. 

## Rückgabetyp
<a name="POWER-return-type"></a>

`DOUBLE PRECISION`

## Beispiel
<a name="POWER-examples"></a>

```
SELECT (SELECT SUM(qtysold) FROM sales, date
WHERE sales.dateid=date.dateid
AND year=2008) * POW((1+7::FLOAT/100),10) qty2010;

+-------------------+
|      qty2010      |
+-------------------+
| 679353.7540885945 |
+-------------------+
```

# Die Funktion RADIANS
<a name="RADIANS"></a>

Die RADIANS-Funktion konvertiert einen Winkel in Grad in die Entsprechung im Bogenmaß. 

## Syntax
<a name="RADIANS-synopsis"></a>

```
RADIANS(number)
```

## Argument
<a name="RADIANS-argument"></a>

 *number (Zahl*   
Der Eingabeparameter ist eine `DOUBLE PRECISION`-Zahl. 

## Rückgabetyp
<a name="RADIANS-return-type"></a>

`DOUBLE PRECISION`

## Beispiel
<a name="RADIANS-examples"></a>

Verwenden Sie das folgende Beispiel, um die Entsprechung in 180 Grad des Radianten zurückzugeben. 

```
SELECT RADIANS(180);

+-------------------+
|      radians      |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# RAND-Funktion
<a name="RAND"></a>

Die RAND-Funktion generiert eine zufällige Gleitkommazahl zwischen 0 und 1. Die RAND-Funktion generiert bei jedem Aufruf eine neue Zufallszahl.

## Syntax
<a name="RAND-syntax"></a>

```
RAND()
```

## Rückgabetyp
<a name="RAND-return-type"></a>

RANDOM gibt einen Wert vom Typ DOUBLE zurück. 

## Beispiel
<a name="RAND-example"></a>

Im folgenden Beispiel wird für jede Zeile in der Tabelle eine Spalte mit zufälligen Gleitkommazahlen zwischen 0 und 1 generiert. `squirrels` Die resultierende Ausgabe wäre eine einzelne Spalte, die eine Liste zufälliger Dezimalwerte mit einem Wert für jede Zeile in der Squirrels-Tabelle enthält. 

```
SELECT rand() FROM squirrels
```

Dieser Abfragetyp ist nützlich, wenn Sie Zufallszahlen generieren müssen, um beispielsweise zufällige Ereignisse zu simulieren oder Zufälligkeit in Ihre Datenanalyse einzubeziehen. Im Kontext der `squirrels` Tabelle kann sie verwendet werden, um jedem Eichhörnchen Zufallswerte zuzuweisen, die dann für die weitere Verarbeitung oder Analyse verwendet werden könnten.

# Die Funktion RANDOM
<a name="RANDOM"></a>

Die RANDOM-Funktion generiert einen zufälligen Wert zwischen 0,0 (einschließlich) und 1,0 (ausschließlich). 

## Syntax
<a name="RANDOM-synopsis"></a>

```
RANDOM()
```

## Rückgabetyp
<a name="RANDOM-return-type"></a>

RANDOM gibt eine DOUBLE PRECISION-Zahl zurück. 

## Beispiele
<a name="RANDOM-examples"></a>

1. Berechnet einen zufälligen Wert zwischen 0 und 99. Wenn die zufällige Zahl 0 bis 1 ist, produziert diese Abfrage eine zufällige Zahl zwischen 0 und 100: 

   ```
   select cast (random() * 100 as int);
   
   INTEGER
   ------
   24
   (1 row)
   ```

1. Rufen Sie eine einheitliche zufällige Stichprobe von 10 Elementen ab:

   ```
   select * 
   from sales
   order by random()
   limit 10;
   ```

   Rufen Sie jetzt eine zufällige Stichprobe von 10 Elementen ab, wählen Sie die Elemente jedoch im Verhältnis zu deren Preis aus. Beispiel: Ein Element, das doppelt so teuer wie ein anderes Element ist, wird doppelt so wahrscheinlich in den Abfrageergebnissen angezeigt:

   ```
   select * 
   from sales
   order by log(1 - random()) / pricepaid
   limit 10;
   ```

1. In diesem Beispiel wird der SET-Befehl verwendet, um einen SEED-Wert festzulegen, sodass RANDOM eine vorhersehbare Zahlenfolge generiert. 

   Geben Sie zunächst drei RANDOM-Ganzzahlen zurück, ohne zuerst den SEED-Wert festzulegen: 

   ```
   select cast (random() * 100 as int);
   INTEGER
   ------
   6
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   68
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   56
   (1 row)
   ```

   Legen Sie nun den SEED-Wert auf `.25` fest und geben Sie drei weitere RANDOM-Zahlen zurück: 

   ```
   set seed to .25;
   select cast (random() * 100 as int);
   INTEGER
   ------
   21
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   79
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   12
   (1 row)
   ```

   Setzen Sie zum Schluss den SEED-Wert auf `.25` zurück und überprüfen Sie, ob RANDOM dieselben Ergebnisse wie in den vorherigen drei Aufrufen zurückgibt: 

   ```
   set seed to .25;
   select cast (random() * 100 as int);
   INTEGER
   ------
   21
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   79
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   12
   (1 row)
   ```

# Die Funktion ROUND
<a name="ROUND"></a>

Die ROUND-Funktion rundet Zahlen auf den nächsten Ganzzahl- oder Dezimalwert auf. 

Die ROUND-Funktion kann optional ein zweites Argument als Ganzzahl umfassen, um die Anzahl der Dezimalstellen für die Rundung in beide Richtungen anzugeben. Wenn Sie das zweite Argument nicht angeben, wird die Funktion auf die nächste ganze Zahl gerundet. Wenn das zweite Argument *>n* angegeben wurde, wird die Funktion auf die nächste Zahl mit einer Genauigkeit von *n* Dezimalstellen gerundet. 

## Syntax
<a name="ROUND-synopsis"></a>

```
ROUND (number [ , integer ] )
```

## Argument
<a name="ROUND-argument"></a>

 *number (Zahl*   
Eine Zahl oder ein Ausdruck, der zu einer Zahl ausgewertet wird. Dabei kann es sich um DECIMAL oder FLOAT8 Type handeln. AWS Clean Rooms kann andere Datentypen gemäß den impliziten Konvertierungsregeln konvertieren. 

*integer* (optional)  
Eine Ganzzahl, die die Zahl der Dezimalstellen für das Runden in beide Richtungen angibt. 

## Rückgabetyp
<a name="ROUND-return-type"></a>

ROUND gibt denselben numerischen Datentyp wie das/die Eingabeargument(e) zurück. 

## Beispiele
<a name="ROUND-examples"></a>

Rundet die für eine bestimmte Transaktion gezahlte Vergütung auf die nächste ganze Zahl. 

```
select commission, round(commission)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |    28
(1 row)
```

Rundet die für eine bestimmte Transaktion gezahlte Vergütung auf die erste Dezimalstelle. 

```
select commission, round(commission, 1)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |  28.1
(1 row)
```

Erweitert für dieselbe Abfrage die Präzision in die entgegengesetzte Richtung. 

```
select commission, round(commission, -1)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |    30
(1 row)
```

# Die Funktion SIGN
<a name="SIGN"></a>

 Die SIGN-Funktion gibt das Vorzeichen (positiv oder negativ) einer Zahl zurück. Das Ergebnis der SIGN-Funktion ist `1`, `-1` oder `0`, was das Vorzeichen des Arguments anzeigt. 

## Syntax
<a name="SIGN-synopsis"></a>

```
SIGN (number)
```

## Argument
<a name="SIGN-argument"></a>

 *number (Zahl*   
Zahl oder Ausdruck, der zu einer Zahl ausgewertet wird. Es kann der DECIMALor FLOAT8 Typ sein. AWS Clean Rooms kann andere Datentypen gemäß den impliziten Konvertierungsregeln konvertieren.

## Rückgabetyp
<a name="SIGN-return-type"></a>

SIGN gibt denselben numerischen Datentyp wie das/die Eingabeargument(e) zurück. Wenn die Eingabe DECIMAL ist, ist die Ausgabe DECIMAL (1,0). 

## Beispiele
<a name="SIGN-examples"></a>

Verwenden Sie das folgende Beispiel, um das Vorzeichen der Decke der Provision zu bestimmten, die für eine bestimmte Verkaufstransaktion aus der Tabelle SALES gezahlt wird. 

```
SELECT commission, SIGN(commission)
FROM sales WHERE salesid=10000;

+------------+------+
| commission | sign |
+------------+------+
|      28.05 |    1 |
+------------+------+
```

# Die Funktion SIN
<a name="SIN"></a>

SIN ist eine trigonometrische Funktion, die den Sinus einer Zahl zurückgibt. Der zurückgegebene Wert liegt zwischen `-1` und `1`. 

## Syntax
<a name="SIN-synopsis"></a>

```
SIN(number)
```

## Argument
<a name="SIN-argument"></a>

 *number (Zahl*   
Eine `DOUBLE PRECISION`-Zahl im Bogenmaß. 

## Rückgabetyp
<a name="SIN-return-type"></a>

`DOUBLE PRECISION` 

## Beispiel
<a name="SIN-examples"></a>

Verwenden Sie das folgende Beispiel, um den Sinus von `-PI` zurückzugeben.

```
SELECT SIN(-PI());

+-------------------------+
|           sin           |
+-------------------------+
| -0.00000000000000012246 |
+-------------------------+
```

# Die Funktion SQRT
<a name="SQRT"></a>

 Die SQRT-Funktion gibt die Quadratwurzel eines numerischen Werts zurück. Die Quadratwurzel ist eine Zahl, die mit sich selbst multipliziert den angegebenen Wert ergibt.

## Syntax
<a name="SQRT-synopsis"></a>

```
SQRT (expression)
```

## Argument
<a name="SQRT-argument"></a>

 *expression*   
Der Ausdruck muss einen Ganzzahl-, Dezimal- oder Gleitkommadatentyp haben. Der Ausdruck kann Funktionen enthalten. Das System könnte implizite Typumwandlungen durchführen. 

## Rückgabetyp
<a name="SQRT-return-type"></a>

SQRT gibt eine DOUBLE PRECISION-Zahl zurück.

## Beispiele
<a name="SQRT-examples"></a>

Im folgenden Beispiel wird die Quadratwurzel einer Zahl zurückgegeben. 

```
select sqrt(16);
               
sqrt
---------------
4
```

Im folgenden Beispiel wird eine implizite Typumwandlung durchgeführt.

```
select sqrt('16');
               
sqrt
---------------
4
```

Im folgenden Beispiel werden Funktionen verschachtelt, um eine komplexere Aufgabe auszuführen. 

```
select sqrt(round(16.4)); 

sqrt
---------------
4
```

Das folgende Beispiel ergibt die Länge des Radius, wenn die Fläche eines Kreises gegeben ist. Der Radius wird beispielsweise in Zoll berechnet, wenn die Fläche in Quadratzoll angegeben ist. Die Fläche in dem Beispiel beträgt 20. 

```
select sqrt(20/pi());
```

Der Wert 5,046265044040321 wird zurückgegeben.

Im folgenden Beispiel wird die Quadratwurzel für COMMISSION-Werte aus der Tabelle SALES zurückgegeben. Die COMMISSION-Spalte ist eine DECIMAL-Spalte. Dieses Beispiel zeigt, wie Sie die Funktion in einer Abfrage mit komplexerer bedingter Logik verwenden können. 

```
select sqrt(commission)
from sales where salesid < 10 order by salesid;

sqrt
------------------
10.4498803820905
3.37638860322683
7.24568837309472
5.1234753829798
...
```

Die folgende Abfrage gibt die gerundete Quadratwurzel für denselben Satz von COMMISSION-Werten zurück. 

```
select salesid, commission, round(sqrt(commission))
from sales where salesid < 10 order by salesid;

salesid | commission | round
--------+------------+-------
      1 |     109.20 |    10
      2 |      11.40 |     3
      3 |      52.50 |     7
      4 |      26.25 |     5
...
```

Weitere Informationen zu Beispieldaten finden Sie AWS Clean Rooms unter [Beispieldatenbank](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).

# Die Funktion TRUNC
<a name="TRUNC"></a>

Die TRUNC-Funktion verkürzt Zahlen auf die vorherige Ganz- oder Dezimalzahlen. 

Die TRUNC-Funktion kann optional ein zweites Argument als Ganzzahl umfassen, um die Anzahl der Dezimalstellen für die Rundung in beide Richtungen anzugeben. Wenn Sie das zweite Argument nicht angeben, wird die Funktion auf die nächste ganze Zahl gerundet. Wenn das zweite Argument *>n* angegeben wurde, wird die Funktion auf die nächste Zahl mit einer Genauigkeit von *>n* Dezimalstellen gerundet. Die Funktion verkürzt auch einen Zeitstempel und gibt ein Datum zurück.

## Syntax
<a name="TRUNC-synopsis"></a>

```
TRUNC (number [ , integer ] |
timestamp )
```

## Argumente
<a name="TRUNC-arguments"></a>

 *number (Zahl*   
Eine Zahl oder ein Ausdruck, der zu einer Zahl ausgewertet wird. Dabei kann es sich um DECIMAL oder FLOAT8 Type handeln. AWS Clean Rooms kann andere Datentypen gemäß den impliziten Konvertierungsregeln konvertieren. 

 *integer* (optional)   
Eine Ganzzahl, die die Zahl der Dezimalstellen der Präzision in beide Richtungen anzeigt. Wenn keine Ganzzahl angegeben wird, wird die Zahl zu einer ganzen Zahl abgeschnitten. Wenn eine Ganzzahl angegeben wird, wird die Zahl an der angegebenen Dezimalstelle abgeschnitten. 

 *timestamp*   
Die Funktion kann auch das Datum aus einem Zeitstempel zurückgeben. (Um einen Zeitstempelwert mit `00:00:00` als Uhrzeit zurückzugeben, wandeln Sie das Funktionsergebnis in einen Zeitstempel um.) 

## Rückgabetyp
<a name="TRUNC-return-type"></a>

TRUNC gibt denselben Datentyp wie das erste Eingabeargument zurück. Für Zeitstempel gibt TRUNC ein Datum zurück. 

## Beispiele
<a name="TRUNC-examples"></a>

Schneidet die Provision ab, die für eine bestimmte Verkaufstransaktion gezahlt wird. 

```
select commission, trunc(commission)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 |   111

(1 row)
```

Schneidet denselben Provisionswert an der ersten Dezimalstelle ab. 

```
select commission, trunc(commission,1)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 | 111.1

(1 row)
```

Schneidet die Provision mit einem negativen Wert für das zweite Argument ab; `111.15` wird auf `110` abgerundet. 

```
select commission, trunc(commission,-1)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 |   110
(1 row)
```

Gibt den Datumsabschnitt aus dem Ergebnis der SYSDATE-Funktion zurück (die einen Zeitstempel zurückgibt): 

```
select sysdate;

timestamp
----------------------------
2011-07-21 10:32:38.248109
(1 row)

select trunc(sysdate);

trunc
------------
2011-07-21
(1 row)
```

Wendet die TRUNC-Funktion auf eine TIMESTAMP-Spalte an. Der Rückgabetyp ist ein Datum. 

```
select trunc(starttime) from event
order by eventid limit 1;

trunc
------------
2008-01-25
(1 row)
```