Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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.
# Datums- und Zeitfunktionen
In diesem Abschnitt finden Sie Informationen zu den skalaren Datums- und Zeitfunktionen, die Amazon Redshift unterstützt.
**Topics**
+ [Zusammenfassung der Datums- und Zeitfunktionen](#date-functions-summary)
+ [Datums- und Zeitfunktionen in Transaktionen](#date-functions-transactions)
+ [Veraltete Funktionen, die ausschließlich für Führungsknoten gelten](#date-functions-deprecated)
+ [Operator \$1 (Verkettung)](r_DATE-CONCATENATE_function.md)
+ [Funktion ADD\$1MONTHS](r_ADD_MONTHS.md)
+ [Funktion AT TIME ZONE](r_AT_TIME_ZONE.md)
+ [Funktion CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md)
+ [Funktion CURRENT\$1DATE](r_CURRENT_DATE_function.md)
+ [Funktion DATE\$1CMP](r_DATE_CMP.md)
+ [Funktion DATE\$1CMP\$1TIMESTAMP](r_DATE_CMP_TIMESTAMP.md)
+ [Funktion DATE\$1CMP\$1TIMESTAMPTZ](r_DATE_CMP_TIMESTAMPTZ.md)
+ [Funktion DATEADD](r_DATEADD_function.md)
+ [Funktion DATEDIFF](r_DATEDIFF_function.md)
+ [Funktion DATE\$1PART](r_DATE_PART_function.md)
+ [Funktion DATE\$1PART\$1YEAR](r_DATE_PART_YEAR.md)
+ [Funktion DATE\$1TRUNC](r_DATE_TRUNC.md)
+ [Funktion EXTRACT](r_EXTRACT_function.md)
+ [Funktion GETDATE](r_GETDATE.md)
+ [Funktion INTERVAL\$1CMP](r_INTERVAL_CMP.md)
+ [Funktion LAST\$1DAY](r_LAST_DAY.md)
+ [Funktion MONTHS\$1BETWEEN](r_MONTHS_BETWEEN_function.md)
+ [Funktion NEXT\$1DAY](r_NEXT_DAY.md)
+ [Funktion SYSDATE](r_SYSDATE.md)
+ [Funktion TIMEOFDAY](r_TIMEOFDAY_function.md)
+ [Funktion TIMESTAMP\$1CMP](r_TIMESTAMP_CMP.md)
+ [Funktion TIMESTAMP\$1CMP\$1DATE](r_TIMESTAMP_CMP_DATE.md)
+ [Funktion TIMESTAMP\$1CMP\$1TIMESTAMPTZ](r_TIMESTAMP_CMP_TIMESTAMPTZ.md)
+ [Funktion TIMESTAMPTZ\$1CMP](r_TIMESTAMPTZ_CMP.md)
+ [Funktion TIMESTAMPTZ\$1CMP\$1DATE](r_TIMESTAMPTZ_CMP_DATE.md)
+ [Funktion TIMESTAMPTZ\$1CMP\$1TIMESTAMP](r_TIMESTAMPTZ_CMP_TIMESTAMP.md)
+ [Funktion TIMEZONE](r_TIMEZONE.md)
+ [Funktion TO\$1TIMESTAMP](r_TO_TIMESTAMP.md)
+ [Die Funktion TRUNC](r_TRUNC_date.md)
+ [Datumsteile für Datums- oder Zeitstempelfunktionen](r_Dateparts_for_datetime_functions.md)
## Zusammenfassung der Datums- und Zeitfunktionen
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/Date_functions_header.html)
**Anmerkung**
Sprungsekunden werden bei Berechnungen der verstrichenen Zeit nicht berücksichtigt.
## Datums- und Zeitfunktionen in Transaktionen
Wenn Sie die folgenden Funktionen mit einem Transaktionsblock (BEGINN … END) ausführen, gibt die Funktion das Startdatum bzw. die Startzeit der aktuellen Transaktion aus, nicht den Beginn der aktuellen Anweisung.
+ SYSDATE
+ TIMESTAMP
+ CURRENT\$1DATE
Die folgenden Funktionen geben immer das Startdatum oder die Startzeit der aktuellen Anweisung aus, selbst wenn sie sich innerhalb eines Transaktionsblocks befinden.
+ GETDATE
+ TIMEOFDAY
## Veraltete Funktionen, die ausschließlich für Führungsknoten gelten
Die folgenden Datumsfunktionen sind veraltet, da sie nur auf dem Führungsknoten ausgeführt werden. Weitere Informationen finden Sie unter [Exklusive Führungsknotenfunktionen](c_SQL_functions_leader_node_only.md).
+ AGE. Verwenden Sie stattdessen [Funktion DATEDIFF](r_DATEDIFF_function.md).
+ CURRENT\$1TIME. Verwenden Sie stattdessen [Funktion GETDATE](r_GETDATE.md) oder [SYSDATE](r_SYSDATE.md).
+ CURRENT\$1TIMESTAMP. Verwenden Sie stattdessen [Funktion GETDATE](r_GETDATE.md) oder [SYSDATE](r_SYSDATE.md).
+ LOCALTIME. Verwenden Sie stattdessen [Funktion GETDATE](r_GETDATE.md) oder [SYSDATE](r_SYSDATE.md).
+ LOCALTIMESTAMP. Verwenden Sie stattdessen [Funktion GETDATE](r_GETDATE.md) oder [SYSDATE](r_SYSDATE.md).
+ ISFINITE
+ NOW. Verwenden Sie stattdessen [Funktion GETDATE](r_GETDATE.md) oder [SYSDATE](r_SYSDATE.md). Wenn Sie die NOW-Funktion in einer materialisierten Ansicht verwenden, wird sie auf den Zeitstempel der Erstellung der materialisierten Ansicht anstelle des aktuellen Zeitstempels gesetzt.
# Operator \$1 (Verkettung)
Verkettet ein DATE mit einer TIME oder TIMETZ auf beiden Seiten des Pluszeichens (\$1) und gibt einen TIMESTAMP oder TIMESTAMPTZ zurück.
## Syntax
```
date + {time | timetz}
```
Die Reihenfolge der Argumente kann umgekehrt werden. Beispiel: *time* \$1 *date*.
## Argumente
*date*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
*variieren*
Eine Spalte vom Datentyp `TIME` oder ein Ausdruck, der implizit zu einem `TIME`-Typ ausgewertet wird.
*timetz*
Eine Spalte vom Datentyp `TIMETZ` oder ein Ausdruck, der implizit zu einem `TIMETZ`-Typ ausgewertet wird.
## Rückgabetyp
TIMESTAMP, wenn die Eingabe *date* \$1 *time* ist.
TIMESTAMPTZ, wenn die Eingabe *date* \$1 *timetz* ist.
## Beispiele
### Beispieleinrichtung
Verwenden Sie den folgenden Befehl, um die in den Beispielen verwendeten Tabellen TIME\$1TEST und TIMETZ\$1TEST einzurichten.
```
create table time_test(time_val time);
insert into time_test values
('20:00:00'),
('00:00:00.5550'),
('00:58:00');
create table timetz_test(timetz_val timetz);
insert into timetz_test values
('04:00:00+00'),
('00:00:00.5550+00'),
('05:58:00+00');
```
### Beispiele mit einer Zeitspalte
Die folgende Beispieltabelle TIME\$1TEST enthält eine Spalte TIME\$1VAL (Typ TIME) mit drei eingefügten Werten.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Im folgenden Beispiel werden ein Datumsliteral und eine TIME\$1VAL-Spalte verkettet.
```
select date '2000-01-02' + time_val as ts from time_test;
ts
---------------------
2000-01-02 20:00:00
2000-01-02 00:00:00.5550
2000-01-02 00:58:00
```
Im folgenden Beispiel werden ein Datumsliteral und eine Zeitspalte verkettet.
```
select date '2000-01-01' + time '20:00:00' as ts;
ts
---------------------
2000-01-01 20:00:00
```
Im folgenden Beispiel werden ein Zeit- und ein Datumsliteral verkettet.
```
select time '20:00:00' + date '2000-01-01' as ts;
ts
---------------------
2000-01-01 20:00:00
```
### Beispiele mit einer TIMETZ-Spalte
Die folgende Beispieltabelle TIMETZ\$1TEST enthält eine Spalte TIMETZ\$1VAL (Typ TIMETZ) mit drei eingefügten Werten.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Im folgenden Beispiel werden ein Datumsliteral und eine TIMETZ\$1VAL-Spalte verkettet.
```
select date '2000-01-01' + timetz_val as ts from timetz_test;
ts
---------------------
2000-01-01 04:00:00+00
2000-01-01 00:00:00.5550+00
2000-01-01 05:58:00+00
```
Im folgenden Beispiel werden eine TIMETZ\$1VAL-Spalte und ein Datumsliteral verkettet.
```
select timetz_val + date '2000-01-01' as ts from timetz_test;
ts
---------------------
2000-01-01 04:00:00+00
2000-01-01 00:00:00.5550+00
2000-01-01 05:58:00+00
```
Im folgenden Beispiel werden ein DATE-Literal und TIMETZ-Literal verkettet. Das Beispiel gibt einen TIMESTAMPTZ zurück, der standardmäßig in der Zeitzone UTC liegt. UTC liegt 8 Stunden vor PST, das Ergebnis liegt also 8 Stunden vor der Eingabezeit.
```
select date '2000-01-01' + timetz '20:00:00 PST' as ts;
ts
------------------------
2000-01-02 04:00:00+00
```
# Funktion ADD\$1MONTHS
ADD\$1MONTHS fügt die angegebene Zahl von Monaten zu einem Datums- oder Zeitstempelwert bzw. -ausdruck hinzu. Die Funktion [DATEADD](r_DATEADD_function.md) bietet eine ähnliche Funktionalität.
## Syntax
```
ADD_MONTHS( {date | timestamp}, integer)
```
## Argumente
*date* \$1 *timestamp*
Eine Spalte vom Datentyp `DATE` oder `TIMESTAMP` bzw. ein Ausdruck, der implizit zu einem `DATE`- oder `TIMESTAMP`-Typ ausgewertet wird. Wenn das Datum der letzte Tag des Monats ist, oder wenn der resultierende Monat kürzer ist, gibt die Funktion im Ergebnis den letzten Tag des Monats aus. Für andere Datumsangaben enthält das Ergebnis die gleiche Tagesnummer wie der Datumsausdruck.
*integer*
Ein Wert vom Datentyp `INTEGER`. Verwenden Sie eine negative Zahl, um Monate von Datumsangaben abzuziehen.
## Rückgabetyp
TIMESTAMP
## Beispiele
Die folgende Abfrage verwendet die Funktion ADD\$1MONTHS innerhalb einer TRUNC-Funktion. Die TRUNC-Funktion entfernt die Tageszeit aus dem Ergebnis von ADD\$1MONTHS. Die Funktion ADD\$1MONTHS fügt jedem Wert aus der Spalte CALDATE 12 Monate hinzu. Die Werte in der Spalte CALDATE sind Datumsangaben.
```
select distinct trunc(add_months(caldate, 12)) as calplus12,
trunc(caldate) as cal
from date
order by 1 asc;
calplus12 | cal
------------+------------
2009-01-01 | 2008-01-01
2009-01-02 | 2008-01-02
2009-01-03 | 2008-01-03
...
(365 rows)
```
Im folgenden Beispiel wird die Funktion ADD\$1MONTHS verwendet, um einem *Zeitstempel* einen Monat hinzuzufügen.
```
select add_months('2008-01-01 05:07:30', 1);
add_months
---------------------
2008-02-01 05:07:30
```
Die folgenden Beispiele illustrieren die Verhaltensweise, wenn die Funktion ADD\$1MONTHS für Datumsangaben verwendet wird, die Monate mit unterschiedlichen Anzahlen von Tagen enthalten. Dieses Beispiel zeigt, wie die Funktion das Hinzufügen eines Monats zum 31. März und das Hinzufügen eines Monats zum 30. April handhabt. Der April hat 30 Tage. Wenn Sie also zum 31. März einen Monat hinzufügen, ergibt sich der 30. April. Der Mai hat 31 Tage. Wenn Sie also zum 30. April einen Monat hinzufügen, ergibt sich der 31. Mai.
```
select add_months('2008-03-31',1);
add_months
---------------------
2008-04-30 00:00:00
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
```
# Funktion AT TIME ZONE
AT TIME ZONE gibt an, welche Zeitzone mit dem Ausdruck TIMESTAMP oder TIMESTAMPTZ zu verwenden ist.
## Syntax
```
AT TIME ZONE 'timezone'
```
## Argumente
*Zeitzone*
Die `TIMEZONE` für den Rückgabewert. Die Zeitzone kann als Zeitzonenname (beispielsweise **'Africa/Kampala'** oder **'Singapore'**) oder als Zeitzonenabkürzung (beispielsweise **'UTC'** oder **'PDT'**) angegeben werden.
Führen Sie den folgenden Befehl aus, um eine Liste der unterstützten Zeitzonennamen anzuzeigen.
```
select pg_timezone_names();
```
Führen Sie den folgenden Befehl aus, um eine Liste der unterstützten Zeitzonenabkürzungen anzuzeigen.
```
select pg_timezone_abbrevs();
```
Weitere Informationen und Beispiele finden Sie unter [Nutzungshinweise zu Zeitstempeln](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
## Rückgabetyp
TIMESTAMPTZ bei Verwendung mit einem TIMESTAMP-Ausdruck. TIMESTAMP bei Verwendung mit einem TIMESTAMPTZ-Ausdruck.
## Beispiele
Im folgenden Beispiel wird ein Zeitstempelwert ohne Zeitzone konvertiert und als MST-Zeit (UTC\$17 in POSIX) interpretiert. Das Beispiel gibt einen Wert des Datentyps TIMESTAMPTZ für die UTC-Zeitzone zurück. Wenn Sie Ihre Standardzeitzone auf eine andere Zeitzone als UTC konfigurieren, wird möglicherweise ein anderes Ergebnis angezeigt.
```
SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-17 03:38:40+00
```
Im folgenden Beispiel wird ein Eingabezeitstempel mit einem Zeitzonenwert verwendet, bei dem die angegebene Zeitzone EST (UTC\$15 in POSIX) lautet, und in MST (UTC\$17 in POSIX) konvertiert. Das Beispiel gibt einen Wert des Datentyps TIMESTAMP zurück.
```
SELECT TIMESTAMPTZ '2001-02-16 20:38:40-05' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-16 18:38:40
```
# Funktion CONVERT\$1TIMEZONE
CONVERT\$1TIMEZONE konvertiert einen Zeitstempel von einer Zeitzone zu einer anderen. Die Funktion passt sich automatisch an die Sommerzeit an.
## Syntax
```
CONVERT_TIMEZONE( ['source_timezone',] 'target_timezone', 'timestamp')
```
## Argumente
*source\$1timezone*
(Optional) Die Zeitzone des aktuellen Zeitstempels. Der Standardwert ist UTC. Weitere Informationen finden Sie unter [Nutzungshinweise zu Zeitstempeln](#CONVERT_TIMEZONE-usage-notes).
*target\$1timezone*
Die Zeitzone für den neuen Zeitstempel. Weitere Informationen finden Sie unter [Nutzungshinweise zu Zeitstempeln](#CONVERT_TIMEZONE-usage-notes).
*timestamp*
Eine Zeitstempelspalte bzw. ein entsprechender Ausdruck, die/der implizit zu einem Zeitstempel konvertiert wird.
## Rückgabetyp
TIMESTAMP
## Nutzungshinweise zu Zeitstempeln
Sie können *source\$1timezone* oder *target\$1timezone* als Zeitzonenname (beispielsweise „Africa/Kampala“ oder „Singapur“) oder als Zeitzonenabkürzung (beispielsweise „UTC“ oder „PDT“) angeben. Sie müssen Zeitzonennamen nicht in Namen oder Abkürzungen in Abkürzungen konvertieren. Sie können beispielsweise einen Zeitstempel aus dem Quellzeitzonennamen „Singapur“ auswählen und ihn in einen Zeitstempel in der Zeitzonenabkürzung „PDT“ konvertieren.
**Anmerkung**
Die Ergebnisse bei der Verwendung eines Zeitzonennamens oder einer Zeitzonenabkürzung können aufgrund lokaler saisonaler Zeit, wie z. B. Sommerzeit, unterschiedlich sein.
### Verwendung eines Zeitzonennamens
Eine aktuelle und vollständige Liste der Zeitzonennamen erhalten Sie, wenn Sie den folgenden Befehl ausführen.
```
select pg_timezone_names();
```
Jede Zeile enthält eine durch Kommata getrennte Zeichenfolge mit dem Namen der Zeitzone, der Abkürzung, dem UTC-Offset und der Angabe, ob in der Zeitzone die Sommerzeit gilt (`t` oder `f`). Das folgende Snippet zeigt beispielsweise zwei Ergebniszeilen. Die erste Zeile enthält die Zeitzone `Antarctica/South Pole`, die Abkürzung `NZDT` mit einem UTC-Offset von `13:00:00` sowie die Angabe `f`, um anzuzeigen, dass die Sommerzeit nicht gilt. Die zweite Zeile enthält die Zeitzone `Europe/Paris`, die Abkürzung `CET` mit einem UTC-Offset von `01:00:00` sowie die Angabe `f`, um anzuzeigen, dass die Sommerzeit gilt.
```
pg_timezone_names
------------------
(Antarctica/South_Pole,NZDT,13:00:00,t)
(Europe/Paris,CET,01:00:00,f)
```
Führen Sie die SQL-Anweisung aus, um die gesamte Liste abzurufen und einen Zeitzonennamen zu finden. Es werden ungefähr 600 Zeilen zurückgegeben. Auch wenn es sich bei einigen der zurückgegebenen Zeitzonennamen um Akronyme handelt (etwa GB, PRC, ROK), werden sie von der Funktion CONVERT\$1TIMEZONE als Zeitzonennamen und nicht als Zeitzonenabkürzungen behandelt.
Wenn Sie eine Zeitzone mit einem Zeitzonennamen angeben, nimmt CONVERT\$1TIMEZONE automatisch Anpassungen für die Sommerzeit oder andere lokale saisonale Protokolle wie beispielsweise Standardzeit oder Winterzeit vor, die für die betreffende Zeitzone während des von „*timestamp*“ angegebenen Datums bzw. der Uhrzeit gelten. So steht beispielsweise „Europe/London“ für UTC im Winter, im Sommer kommt eine Stunde dazu. Beachten Sie, dass Amazon Redshift die [IANA-Zeitzonendatenbank](https://www.iana.org/time-zones) als maßgebliche Quelle für die Zeitzonenspezifikation verwendet.
### Verwendung einer Zeitzonenabkürzung
Führen Sie für eine vollständige Liste der Zeitzonenabkürzungen den folgenden Befehl aus.
```
select pg_timezone_abbrevs();
```
Die Ergebnisse enthalten eine durch Kommata getrennte Zeichenfolge mit der Abkürzung der Zeitzone, dem UTC-Offset und der Angabe, ob in der Zeitzone die Sommerzeit gilt (`t` oder `f`). Das folgende Snippet zeigt beispielsweise zwei Ergebniszeilen. Die erste Zeile enthält die Abkürzung für Pacific Daylight Time `PDT` mit einem UTC-Offset von `-07:00:00` sowie die Angabe `t`, um anzuzeigen, dass die Sommerzeit gilt. Die zweite Zeile enthält die Abkürzung für Pacific Daylight Time `PST` mit einem UTC-Offset von `-08:00:00` sowie die Angabe `f`, um anzuzeigen, dass die Sommerzeit nicht gilt.
```
pg_timezone_abbrevs
--------------------
(PDT,-07:00:00,t)
(PST,-08:00:00,f)
```
Führen Sie die SQL-Anweisung aus, um die gesamte Liste abzurufen und anhand des Offsets und der Angabe zur Sommerzeit nach einer Abkürzung zu suchen. Es werden ungefähr 200 Zeilen zurückgegeben.
Zeitzonenabkürzungen stehen für eine feste Verschiebung von der UTC. Wenn Sie eine Zeitzone mit einer Zeitzonenabkürzung angeben, verwendet CONVERT\$1TIMEZONE die feste Verschiebung von UTC und nimmt keine Anpassungen an saisonale lokale Protokolle vor.
### Verwendung des POSIX-Stil-Formats
Eine Zeitzonenspezifikation im POSIX-Stil hat die Form *STDoffsetSTDoffset**DST*, wobei *STD* eine Abkürzung für eine Zeitzone ist, *Offset* der numerische Offset in Stunden westlich von UTC ist und *DST* eine optionale Abkürzung für Sommerzeitzonen ist. Für die Sommerzeit wird angenommen, dass sie eine Stunde vor der angegebenen Verschiebung liegt.
Zeitzonenformate im POSIX-Stil verwenden positive Verschiebungen westlich von Greenwich; im Gegensatz dazu verwendet die ISO-8601-Konvention östlich von Greenwich positive Werte.
Es folgen einige Beispiele für Zeitzonen im POSIX-Stil:
+ PST8
+ PST8PDT
+ EST5
+ EST5EDT
**Anmerkung**
Amazon Redshift validiert Zeitzonenangaben im POSIX-Stil-Format nicht, es kann daher sein, dass die Zeitzone auf einen ungültigen Wert gesetzt wird. Beispielsweise führt der folgende Befehl nicht zu einem Fehler, obwohl dadurch die Zeitzone auf einen ungültigen Wert gesetzt wird.
```
set timezone to ‘xxx36’;
```
## Beispiele
Viele der Beispiele verwenden den TICKIT-Beispieldatensatz. Weitere Informationen finden Sie unter [Beispieldatenbank](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
Das folgende Beispiel konvertiert den Zeitstempelwert von der Standardzeitzone UTC zu PST.
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
Das folgende Beispiel konvertiert den Zeitstempelwert in der Spalte LISTTIME von der Standardzeitzone UTC zu PST. Obwohl der Zeitstempel in der Sommerzeitzone liegt, wird er zur Standardzeit konvertiert, da die Zielzeitzone als Abkürzung (PST) angegeben ist.
```
select listtime, convert_timezone('PST', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+-------------------
2008-08-24 09:36:12 2008-08-24 01:36:12
```
Im folgenden Beispiel wird eine LISTTIME-Spalte mit einem Zeitstempel von der Standard-UTC-Zeitzone in eine US/Pacific Zeitzone konvertiert. Die Zielzeitzone verwendet einen Zeitzonennamen, und der Zeitstempel liegt im Sommerzeitzeitraum, weshalb die Funktion die Sommerzeit ausgibt.
```
select listtime, convert_timezone('US/Pacific', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+---------------------
2008-08-24 09:36:12 | 2008-08-24 02:36:12
```
Das folgende Beispiel konvertiert eine Zeitstempelzeichenfolge von EST zu PST:
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
Das folgende Beispiel konvertiert einen Zeitstempel zu US Eastern Standard Time, da die Zielzeitzone einen Zeitzonennamen (America/New York) verwendet und der Zeitstempel im Standardzeitzeitraum liegt.
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
Das folgende Beispiel konvertiert einen Zeitstempel zu US Eastern Daylight Time, da die Zielzeitzone einen Zeitzonennamen (America/New York) verwendet und der Zeitstempel im Sommerzeitzeitraum liegt.
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
Das folgende Beispiel illustriert die Verwendung von Verschiebungen.
```
SELECT CONVERT_TIMEZONE('GMT','NEWZONE +2','2014-05-17 12:00:00') as newzone_plus_2,
CONVERT_TIMEZONE('GMT','NEWZONE-2:15','2014-05-17 12:00:00') as newzone_minus_2_15,
CONVERT_TIMEZONE('GMT','America/Los_Angeles+2','2014-05-17 12:00:00') as la_plus_2,
CONVERT_TIMEZONE('GMT','GMT+2','2014-05-17 12:00:00') as gmt_plus_2;
newzone_plus_2 | newzone_minus_2_15 | la_plus_2 | gmt_plus_2
---------------------+---------------------+---------------------+---------------------
2014-05-17 10:00:00 | 2014-05-17 14:15:00 | 2014-05-17 10:00:00 | 2014-05-17 10:00:00
(1 row)
```
# Funktion CURRENT\$1DATE
CURRENT\$1DATE gibt ein Datum in der Zeitzone der aktuellen Sitzung (standardmäßig UTC) im Standardformat zurück:. YYYY-MM-DD
**Anmerkung**
CURRENT\$1DATE gibt das Startdatum für die aktuelle Transaktion aus, nicht für den Start der aktuellen Anweisung. Angenommen, Sie starten eine mehrere Anweisungen umfassende Transaktion am 01.10.08 um 23:59 Uhr und die Anweisung mit CURRENT\$1DATE wird am 02.10.08 um 00:00 Uhr ausgeführt. CURRENT\$1DATE gibt dann `10/01/08` zurück, nicht `10/02/08`.
## Syntax
```
CURRENT_DATE
```
## Rückgabetyp
DATUM
## Beispiele
Das folgende Beispiel gibt das aktuelle Datum zurück (in AWS-Region dem die Funktion ausgeführt wird).
```
select current_date;
date
------------
2008-10-01
```
Mit dem folgenden Beispiel werden eine Tabelle erstellt, eine Zeile eingefügt, deren Standardwert für die Spalte `todays_date` CURRENT\$1DATE lautet, und dann alle Zeilen in der Tabelle ausgewählt.
```
CREATE TABLE insert_dates(
label varchar(128) NOT NULL,
todays_date DATE DEFAULT CURRENT_DATE);
INSERT INTO insert_dates(label)
VALUES('Date row inserted');
SELECT * FROM insert_dates;
label | todays_date
------------------+-------------
Date row inserted | 2023-05-10
```
# Funktion DATE\$1CMP
DATE\$1CMP vergleicht zwei Datumsangaben. Die Funktion gibt `0` aus, wenn beide identisch sind, sowie `1`, wenn *date1* größer ist, und `-1`, wenn *date2* größer ist.
## Syntax
```
DATE_CMP(date1, date2)
```
## Argumente
*date1*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der zu einem `DATE`-Typ ausgewertet wird.
*date2*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der zu einem `DATE`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Die folgende Abfrage vergleicht die DATE-Werte der Spalte CALDATE mit dem Datum 4. Januar 2008 und gibt aus, ob der Wert in CALDATE vor (`-1`), am (`0`) oder nach dem (`1`) 4. Januar 2008 liegt:
```
select caldate, '2008-01-04',
date_cmp(caldate,'2008-01-04')
from date
order by dateid
limit 10;
caldate | ?column? | date_cmp
-----------+------------+----------
2008-01-01 | 2008-01-04 | -1
2008-01-02 | 2008-01-04 | -1
2008-01-03 | 2008-01-04 | -1
2008-01-04 | 2008-01-04 | 0
2008-01-05 | 2008-01-04 | 1
2008-01-06 | 2008-01-04 | 1
2008-01-07 | 2008-01-04 | 1
2008-01-08 | 2008-01-04 | 1
2008-01-09 | 2008-01-04 | 1
2008-01-10 | 2008-01-04 | 1
(10 rows)
```
# Funktion DATE\$1CMP\$1TIMESTAMP
DATE\$1CMP\$1TIMESTAMP vergleicht ein Datum mit einem Zeitstempel und gibt `0` aus, wenn die Werte identisch sind, sowie `1`, wenn *date* chronologisch größer ist, und `-1`, wenn *timestamp* größer ist.
## Syntax
```
DATE_CMP_TIMESTAMP(date, timestamp)
```
## Argumente
*date*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der zu einem `DATE`-Typ ausgewertet wird.
*timestamp*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der zu einem `TIMESTAMP`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht das Datum `2008-06-18` mit LISTTIME. Die Werte der Spalte LISTTIME sind Zeitstempel. Vor diesem Datum erstellte Auflistungen geben `1` aus, danach erstellte Auflistungen `-1`.
```
select listid, '2008-06-18', listtime,
date_cmp_timestamp('2008-06-18', listtime)
from listing
order by 1, 2, 3, 4
limit 10;
listid | ?column? | listtime | date_cmp_timestamp
--------+------------+---------------------+--------------------
1 | 2008-06-18 | 2008-01-24 06:43:29 | 1
2 | 2008-06-18 | 2008-03-05 12:25:29 | 1
3 | 2008-06-18 | 2008-11-01 07:35:33 | -1
4 | 2008-06-18 | 2008-05-24 01:18:37 | 1
5 | 2008-06-18 | 2008-05-17 02:29:11 | 1
6 | 2008-06-18 | 2008-08-15 02:08:13 | -1
7 | 2008-06-18 | 2008-11-15 09:38:15 | -1
8 | 2008-06-18 | 2008-11-09 05:07:30 | -1
9 | 2008-06-18 | 2008-09-09 08:03:36 | -1
10 | 2008-06-18 | 2008-06-17 09:44:54 | 1
(10 rows)
```
# Funktion DATE\$1CMP\$1TIMESTAMPTZ
DATE\$1CMP\$1TIMESTAMPTZ vergleicht ein Datum mit einem Zeitstempel mit Zeitzone und gibt `0` aus, wenn die Werte identisch sind, sowie `1`, wenn *date* chronologisch größer ist, und `-1`, wenn *timestamptz* größer ist.
## Syntax
```
DATE_CMP_TIMESTAMPTZ(date, timestamptz)
```
## Argumente
*date*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
*timestamptz*
Eine Spalte vom Datentyp `TIMESTAMPTZ` oder ein Ausdruck, der implizit zu einem `TIMESTAMPTZ`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht das Datum `2008-06-18` mit LISTTIME. Vor diesem Datum erstellte Auflistungen geben `1` aus, danach erstellte Auflistungen `-1`.
```
select listid, '2008-06-18', CAST(listtime AS timestamptz),
date_cmp_timestamptz('2008-06-18', CAST(listtime AS timestamptz))
from listing
order by 1, 2, 3, 4
limit 10;
listid | ?column? | timestamptz | date_cmp_timestamptz
--------+------------+------------------------+----------------------
1 | 2008-06-18 | 2008-01-24 06:43:29+00 | 1
2 | 2008-06-18 | 2008-03-05 12:25:29+00 | 1
3 | 2008-06-18 | 2008-11-01 07:35:33+00 | -1
4 | 2008-06-18 | 2008-05-24 01:18:37+00 | 1
5 | 2008-06-18 | 2008-05-17 02:29:11+00 | 1
6 | 2008-06-18 | 2008-08-15 02:08:13+00 | -1
7 | 2008-06-18 | 2008-11-15 09:38:15+00 | -1
8 | 2008-06-18 | 2008-11-09 05:07:30+00 | -1
9 | 2008-06-18 | 2008-09-09 08:03:36+00 | -1
10 | 2008-06-18 | 2008-06-17 09:44:54+00 | 1
(10 rows)
```
# Funktion DATEADD
Erhöht einen DATE-, TIME-, TIMETZ- oder TIMESTAMP-Wert um ein bestimmtes Intervall.
## Syntax
```
DATEADD( datepart, interval, {date|time|timetz|timestamp} )
```
## Argumente
*datepart*
Der Datumsteil (z. B. Jahr, Monat, Tag oder Stunde), für den die Funktion gilt. Weitere Informationen finden Sie unter [Datumsteile für Datums- oder Zeitstempelfunktionen](r_Dateparts_for_datetime_functions.md).
*Intervall*
Eine Ganzzahl, di das Intervall angibt (z. B. eine Anzahl von Tagen), das dem Zielausdruck hinzugefügt werden soll. Bei einer negativen Ganzzahl wird das Intervall subtrahiert.
*date*\$1*time*\$1*timetz*\$1*timestamp*
Eine DATE-, TIME-, TIMETZ- oder TIMESTAMP-Spalte bzw. ein entsprechender Ausdruck, die/der implizit zu einem DATE, TIME, TIMETZ oder TIMESTAMP konvertiert wird. Der DATE-, TIME-, TIMETZ- oder TIMESTAMP-Ausdruck muss den angegebenen Datumsteil enthalten.
## Rückgabetyp
TIMESTAMP oder TIME oder TIMEZ abhängig vom Eingabedatendatentyp.
## Beispiele mit einer DATE-Spalte
Im folgenden Beispiel werden 30 Tage zu jedem Datum hinzugefügt, das in der DATE-Tabelle vorhanden ist.
```
select dateadd(day,30,caldate) as novplus30
from date
where month='NOV'
order by dateid;
novplus30
---------------------
2008-12-01 00:00:00
2008-12-02 00:00:00
2008-12-03 00:00:00
...
(30 rows)
```
Im folgenden Beispiel werden 18 Monate zu einem Literal-Datumswert hinzugefügt.
```
select dateadd(month,18,'2008-02-28');
date_add
---------------------
2009-08-28 00:00:00
(1 row)
```
Der Standard-Spaltenname für eine DATEADD-Funktion ist DATE\$1ADD. Der Standard-Zeitstempel für einen Datumswert ist `00:00:00`.
Im folgenden Beispiel werden 30 Minuten zu einem Datumswert hinzugefügt, der keinen Zeitstempel angibt.
```
select dateadd(m,30,'2008-02-28');
date_add
---------------------
2008-02-28 00:30:00
(1 row)
```
Sie können Datumsteile ausschreiben oder abkürzen. In diesem Fall steht das *m* für Minuten, nicht für Monate.
## Beispiele mit einer TIME-Spalte
Die folgende Beispieltabelle TIME\$1TEST enthält eine Spalte TIME\$1VAL (Typ TIME) mit drei eingefügten Werten.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Im folgenden Beispiel werden jedem TIME\$1VAL in der TIME\$1TEST-Tabelle 5 Minuten hinzugefügt.
```
select dateadd(minute,5,time_val) as minplus5 from time_test;
minplus5
---------------
20:05:00
00:05:00.5550
01:03:00
```
Im folgenden Beispiel werden 8 Stunden zu einem Literal-Zeitwert hinzugefügt.
```
select dateadd(hour, 8, time '13:24:55');
date_add
---------------
21:24:55
```
Das folgende Beispiel wird angezeigt, wenn eine Zeit über 24:00:00 oder unter 00:00:00 liegt.
```
select dateadd(hour, 12, time '13:24:55');
date_add
---------------
01:24:55
```
## Beispiele mit einer TIMETZ-Spalte
Die Ausgabewerte in diesen Beispielen sind in der Standardzeitzone UTC angegeben.
Die folgende Beispieltabelle TIMETZ\$1TEST enthält eine Spalte TIMETZ\$1VAL (Typ TIMETZ) mit drei eingefügten Werten.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Im folgenden Beispiel werden jedem TIMETZ\$1VAL in der TIMETZ\$1TEST-Tabelle 5 Minuten hinzugefügt.
```
select dateadd(minute,5,timetz_val) as minplus5_tz from timetz_test;
minplus5_tz
---------------
04:05:00+00
00:05:00.5550+00
06:03:00+00
```
Im folgenden Beispiel werden 2 Stunden zu einem Literal-Timetz-Wert hinzugefügt.
```
select dateadd(hour, 2, timetz '13:24:55 PST');
date_add
---------------
23:24:55+00
```
## Beispiele mit einer TIMESTAMP-Spalte
Die Ausgabewerte in diesen Beispielen sind in der Standardzeitzone UTC angegeben.
Die folgende Beispieltabelle TIMESTAMP\$1TEST enthält eine Spalte TIMESTAMP\$1VAL (Typ TIMESTAMP) mit drei eingefügten Werten.
```
SELECT timestamp_val FROM timestamp_test;
timestamp_val
------------------
1988-05-15 10:23:31
2021-03-18 17:20:41
2023-06-02 18:11:12
```
Im folgenden Beispiel werden nur den TIMESTAMP\$1VAL-Werten in TIMESTAMP\$1TEST aus der Zeit vor dem Jahr 2000 20 Jahre hinzugefügt.
```
SELECT dateadd(year,20,timestamp_val)
FROM timestamp_test
WHERE timestamp_val < to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH:MI:SS');
date_add
---------------
2008-05-15 10:23:31
```
Im folgenden Beispiel werden einem literalen Zeitstempelwert, der ohne Sekundenanzeige geschrieben wurde, 5 Sekunden hinzugefügt.
```
SELECT dateadd(second, 5, timestamp '2001-06-06');
date_add
---------------
2001-06-06 00:00:05
```
## Nutzungshinweise
Die Funktionen DATEADD(month, ...) und ADD\$1MONTHS behandeln Daten am Ende von Monaten in unterschiedlicher Weise:
+ ADD\$1MONTHS: Wenn das Datum, das Sie hinzufügen, der letzte Tag des Monats ist, ist das Ergebnis immer der letzte Tag des Ergebnismonats, unabhängig von der Länge des Monats. Zum Beispiel: 30. April \$1 1 Monat = 31. Mai.
```
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
+ DATEADD: Wenn das Datum, zu dem Sie hinzufügen, weniger Tage enthält als der Ergebnismonat, entspricht das Ergebnis dem Tag des Ergebnismonats, nicht dem letzten Tag des Monats. Zum Beispiel: 30. April \$1 1 Monat = 30. Mai.
```
select dateadd(month,1,'2008-04-30');
date_add
---------------------
2008-05-30 00:00:00
(1 row)
```
Die Funktion DATEADD behandelt das Schaltjahrdatum 02-29 anders als DATEADD(month, 12, ...) oder DATEADD(year, 1, ...).
```
select dateadd(month,12,'2016-02-29');
date_add
---------------------
2017-02-28 00:00:00
select dateadd(year, 1, '2016-02-29');
date_add
---------------------
2017-03-01 00:00:00
```
# Funktion DATEDIFF
DATEDIFF gibt die Differenz zwischen den Datumsteilen zweier Datums- oder Uhrzeitausdrücke aus.
## Syntax
```
DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )
```
## Argumente
*datepart*
Der spezifische Teil des Datums- oder Zeitwerts (Jahr, Monat oder Tag, Stunde, Minute, Sekunde, Millisekunde oder Mikrosekunde) auf den die Funktion angewendet wird. Weitere Informationen finden Sie unter [Datumsteile für Datums- oder Zeitstempelfunktionen](r_Dateparts_for_datetime_functions.md).
Insbesondere bestimmt DATEDIFF die Anzahl von Datumsteilgrenzen, die zwischen zwei Ausdrücken überschritten werden. Nehmen wir an, dass Sie den Jahresdifferenz zwischen zwei Daten berechnen möchten, `12-31-2008` und `01-01-2009`. In diesem Fall gibt die Funktion 1 Jahr zurück, obwohl die Daten nur einen Tag auseinanderliegen. Wenn Sie die Differenz in Stunden zwischen zwei Zeitstempeln, `01-01-2009 8:30:00` und `01-01-2009 10:00:00` ermitteln, ist das Ergebnis 2 Stunden. Wenn Sie die Differenz in Stunden zwischen zwei Zeitstempeln, `8:30:00` und `10:00:00` ermitteln, ist das Ergebnis 2 Stunden.
*date*\$1*time*\$1*timetz*\$1*timestamp*
Eine DATE-, TIME-, TIMETZ- oder TIMESTAMP-Spalte bzw. ein entsprechender Ausdruck, die/der implizit zu einem DATE, TIME, TIMETZ oder TIMESTAMP konvertiert wird. Beide Ausdrücke müssen den angegebenen Datums- oder Zeitteil enthalten. Wenn das zweite Datum bzw. die zweite Uhrzeit größer als das/die erste ist, ist das Ergebnis positiv. Wenn das zweite Datum bzw. die zweite Uhrzeit vor dem/der ersten liegt, ist das Ergebnis negativ.
## Rückgabetyp
BIGINT
## Beispiele mit einer DATE-Spalte
Im folgenden Beispiel wird die Differenz als Anzahl von Wochen zwischen zwei Literal-Datumswerten berechnet.
```
select datediff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
Im folgenden Beispiel wird die Differenz in Stunden zwischen zwei Literal-Datumswerten ermittelt. Wenn Sie den Zeitwert für ein Datum nicht angeben, wird standardmäßig 00:00:00 verwendet.
```
select datediff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
Im folgenden Beispiel wird die Differenz in Tagen zwischen zwei TIMESTAMETZ-Literalwerten ermittelt.
```
Select datediff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
Im folgenden Beispiel wird die Differenz in Tagen zwischen zwei Daten in derselben Zeile einer Tabelle ermittelt.
```
select * from date_table;
start_date | end_date
-----------+-----------
2009-01-01 | 2009-03-23
2023-01-04 | 2024-05-04
(2 rows)
select datediff(day, start_date, end_date) as duration from date_table;
duration
---------
81
486
(2 rows)
```
Im folgenden Beispiel wird die Differenz als Anzahl von Quartalen zwischen einem in der Vergangenheit liegenden Literalwert und dem heutigen Datum berechnet. Bei diesem Beispiel wird davon ausgegangen, dass das aktuelle Datum der 5. Juni 2008 ist. Sie können Datumsteile ausschreiben oder abkürzen. Der Standard-Spaltenname für die DATEDIFF-Funktion ist DATE\$1DIFF.
```
select datediff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
Das folgende Beispiel verbindet die Tabellen SALES und LISTING zur Berechnung, wie viel Tage nach ihrer Auflistung Tickets für die Auflistungen 1000 bis 1005 verkauft wurden. Die längste Wartezeit für den Verkauf dieser Auflistungen betrug 15 Tage, und die kürzeste lag unter einem Tag (0 Tage).
```
select priceperticket,
datediff(day, listtime, saletime) as wait
from sales, listing where sales.listid = listing.listid
and sales.listid between 1000 and 1005
order by wait desc, priceperticket desc;
priceperticket | wait
---------------+------
96.00 | 15
123.00 | 11
131.00 | 9
123.00 | 6
129.00 | 4
96.00 | 4
96.00 | 0
(7 rows)
```
Dieses Beispiel berechnet die durchschnittliche Zahl von Stunden, für die Verkäufer auf alle Ticketverkäufe warteten.
```
select avg(datediff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## Beispiele mit einer TIME-Spalte
Die folgende Beispieltabelle TIME\$1TEST enthält eine Spalte TIME\$1VAL (Typ TIME) mit drei eingefügten Werten.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Im folgenden Beispiel wird die Differenz als Anzahl von Stunden zwischen der TIME\$1VAL-Spalte und einem Zeitliteral berechnet.
```
select datediff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
Im folgenden Beispiel wird die Differenz als Anzahl von Minuten zwischen zwei Literal-Zeitwerten berechnet.
```
select datediff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## Beispiele mit einer TIMETZ-Spalte
Die folgende Beispieltabelle TIMETZ\$1TEST enthält eine Spalte TIMETZ\$1VAL (Typ TIMETZ) mit drei eingefügten Werten.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Im folgenden Beispiel werden die Differenzen als Anzahl von Stunden zwischen dem TIMETZ-Literal und timetz\$1val berechnet.
```
select datediff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
Im folgenden Beispiel wird die Differenz als Anzahl von Stunden zwischen zwei Literal-TIMETZ-Werten berechnet.
```
select datediff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# Funktion DATE\$1PART
DATE\$1PART extrahiert Datumsteilwerte aus einem Ausdruck. DATE\$1PART ist synonym mit der Funktion PGDATE\$1PART.
## Syntax
```
DATE_PART(datepart, {date|timestamp})
```
## Argumente
*datepart*
Ein Bezeichnerliteral oder eine Zeichenfolge des spezifischen Teils des Datumswertes (z. B. Jahr, Monat oder Tag), für den die Funktion gilt. Weitere Informationen finden Sie unter [Datumsteile für Datums- oder Zeitstempelfunktionen](r_Dateparts_for_datetime_functions.md).
\$1*date*\$1*timestamp*\$1
Eine Datums- oder Zeitstempelspalte bzw. ein entsprechender Ausdruck, die/der implizit zu einem Datum oder Zeitstempel konvertiert wird. Die Spalte bzw. der Ausdruck unter *date* oder *timestamp* muss den in *datepart* angegebenen Datumsteil enthalten.
## Rückgabetyp
DOUBLE
## Beispiele
Der Standard-Spaltenname für die DATE\$1PART-Funktion ist `pgdate_part`.
Weitere Hinweise zu den Daten, die in einigen dieser Beispiele verwendet werden, finden Sie unter [Beispieldatenbank](c_sampledb.md).
Im folgenden Beispiel wird der Minutenwert aus einem Zeitstempelliteral ermittelt.
```
SELECT DATE_PART(minute, timestamp '20230104 04:05:06.789');
pgdate_part
-----------
5
```
Im folgenden Beispiel wird der Wochenwert aus einem Zeitstempelliteral ermittelt. Die Berechnung der Wochenzahl erfolgt gemäß ISO-Standard 8601. Weitere Informationen finden Sie unter [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(week, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
18
```
Im folgenden Beispiel wird der Tag des Monats aus einem Zeitstempelliteral ermittelt.
```
SELECT DATE_PART(day, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
2
```
Im folgenden Beispiel wird der Wochentag aus einem Zeitstempelliteral ermittelt. Die Datumsberechnung „Wochentag“ ist eine Ganzzahl zwischen 0 und 6, beginnend mit Sonntag.
```
SELECT DATE_PART(dayofweek, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
1
```
Das folgende Beispiel ermittelt das Jahrhundert aus einem Zeitstempelliteral. Die Berechnung des Jahrhunderts erfolgt gemäß ISO-Standard 8601. Weitere Informationen finden Sie unter [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(century, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
21
```
Im folgenden Beispiel wird das Jahrtausend aus einem Zeitstempelliteral ermittelt. Die Berechnung des Jahrtausends erfolgt gemäß ISO-Standard 8601. Weitere Informationen finden Sie unter [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(millennium, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
3
```
Im folgenden Beispiel werden die Mikrosekunden aus einem Zeitstempelliteral ermittelt. Die Berechnung der Mikrosekunden erfolgt gemäß ISO-Standard 8601. Weitere Informationen finden Sie unter [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(microsecond, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
789000
```
Im folgenden Beispiel wird der Monat aus einem Datumsliteral ermittelt.
```
SELECT DATE_PART(month, date '20220502');
pgdate_part
-----------
5
```
Im folgenden Beispiel wird die Funktion DATE\$1PART auf eine Spalte in einer Tabelle angewendet.
```
SELECT date_part(w, listtime) AS weeks, listtime
FROM listing
WHERE listid=10
weeks | listtime
------+---------------------
25 | 2008-06-17 09:44:54
(1 row)
```
Sie können Datumsteile ausschreiben oder abkürzen; in diesem Fall steht *w* für Wochen.
Der Datumsteil „Wochentag“ gibt eine Ganzzahl zwischen 0 und 6 aus, beginnend mit Sonntag. Verwenden Sie DATE\$1PART mit dow (DAYOFWEEK) zur Anzeige von Ereignissen an einem Samstag.
```
SELECT date_part(dow, starttime) AS dow, starttime
FROM event
WHERE date_part(dow, starttime)=6
ORDER BY 2,1;
dow | starttime
-----+---------------------
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
...
(1147 rows)
```
# Funktion DATE\$1PART\$1YEAR
Die Funktion DATE\$1PART\$1YEAR extrahiert das Jahr aus einem Datum.
## Syntax
```
DATE_PART_YEAR(date)
```
## Argument
*date*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Im folgenden Beispiel wird das Jahr aus einem Datumsliteral ermittelt.
```
SELECT DATE_PART_YEAR(date '20220502 04:05:06.789');
date_part_year
---------------
2022
```
Das folgende Beispiel extrahiert das Jahr aus der Spalte CALDATE. Die Werte in der Spalte CALDATE sind Datumsangaben. Weitere Informationen zu den hier verwendeten Daten finden Sie unter [Beispieldatenbank](c_sampledb.md).
```
select caldate, date_part_year(caldate)
from date
order by
dateid limit 10;
caldate | date_part_year
-----------+----------------
2008-01-01 | 2008
2008-01-02 | 2008
2008-01-03 | 2008
2008-01-04 | 2008
2008-01-05 | 2008
2008-01-06 | 2008
2008-01-07 | 2008
2008-01-08 | 2008
2008-01-09 | 2008
2008-01-10 | 2008
(10 rows)
```
# Funktion DATE\$1TRUNC
Die Funktion DATE\$1TRUNC verkürzt alle Zeitstempelausdrücke oder Literale auf der Grundlage des angegebenen Datumsteils, beispielsweise Stunde, Tag oder Monat.
## Syntax
```
DATE_TRUNC('datepart', timestamp)
```
## Argumente
*datepart*
Der Datumsteil, auf den der Zeitstempelwert verkürzt werden soll. Die Eingabe *timestamp* wird entsprechend der Genauigkeit der Eingabe *datepart* verkürzt. Bei Verwendung von `month` beispielsweise wird auf den ersten Tag des Monats verkürzt. Gültige Formate sind folgende:
+ Mikrosekunde, Mikrosekunden
+ Millisekunde, Millisekunden
+ Sekunde, Sekunden
+ Minute, Minuten
+ Stunde, Stunden
+ Tag, Tage
+ Woche, Wochen
+ Monat, Monate
+ Quartal, Quartale
+ Jahr, Jahre
+ Dekade, Dekaden
+ Jahrhundert, Jahrhunderte
+ Jahrtausend, Jahrtausende
Weitere Informationen zu Abkürzungen einiger Formate finden Sie unter [Datumsteile für Datums- oder Zeitstempelfunktionen](r_Dateparts_for_datetime_functions.md)
*timestamp*
Eine Zeitstempelspalte bzw. ein entsprechender Ausdruck, die/der implizit zu einem Zeitstempel konvertiert wird.
## Rückgabetyp
TIMESTAMP
## Beispiele
Verkürzen des Eingabezeitstempels auf die Sekunde
```
SELECT DATE_TRUNC('second', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:06
```
Verkürzen des Eingabezeitstempels auf die Minute
```
SELECT DATE_TRUNC('minute', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:00
```
Verkürzen des Eingabezeitstempels auf die Stunde
```
SELECT DATE_TRUNC('hour', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:00:00
```
Verkürzen des Eingabezeitstempels auf den Tag
```
SELECT DATE_TRUNC('day', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 00:00:00
```
Verkürzen des Eingabezeitstempels auf den ersten Tag eines Monats
```
SELECT DATE_TRUNC('month', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Verkürzen des Eingabezeitstempels auf den ersten Tag eines Quartals
```
SELECT DATE_TRUNC('quarter', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Verkürzen des Eingabezeitstempels auf den ersten Tag eines Jahres
```
SELECT DATE_TRUNC('year', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-01-01 00:00:00
```
Verkürzen des Eingabezeitstempels auf den ersten Tag eines Jahrhunderts
```
SELECT DATE_TRUNC('millennium', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2001-01-01 00:00:00
```
Verkürzen des Eingabezeitstempels auf den Montag der Woche.
```
select date_trunc('week', TIMESTAMP '20220430 04:05:06.789');
date_trunc
2022-04-25 00:00:00
```
Im folgenden Beispiel verwendet die Funktion DATE\$1TRUNC den Datumsteil „Woche“ zur Rückgabe des Datums des Montags jeder Woche.
```
select date_trunc('week', saletime), sum(pricepaid) from sales where
saletime like '2008-09%' group by date_trunc('week', saletime) order by 1;
date_trunc | sum
------------+-------------
2008-09-01 | 2474899
2008-09-08 | 2412354
2008-09-15 | 2364707
2008-09-22 | 2359351
2008-09-29 | 705249
```
# Funktion EXTRACT
Die EXTRACT-Funktion gibt einen Datums- oder Uhrzeitteil von einem TIMESTAMP-, TIMESTAMPTZ-, TIME-, TIMETZ-, INTERVAL YEAR TO MONTH- oder INTERVAL DAY TO SECOND-Wert zurück. Beispiele hierfür sind ein Tag, Monat, Jahr, eine Stunde, Minute, Sekunde, Millisekunde oder Mikrosekunde aus einem Zeitstempel.
## Syntax
```
EXTRACT(datepart FROM source)
```
## Argumente
*datepart*
Das zu extrahierende Unterfeld eines Datums- oder Uhrzeitwerts, z. B. Tag, Monat, Jahr, Stunde, Minute, Sekunde, Millisekunde oder Mikrosekunde. Für mögliche Werte vgl. [Datumsteile für Datums- oder Zeitstempelfunktionen](r_Dateparts_for_datetime_functions.md).
*source*
Eine Spalte oder ein Ausdruck, der zum Datentyp TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH oder INTERVAL DAY TO SECOND ausgewertet wird.
## Rückgabetyp
INTEGER, wenn der Wert *source* zum Datentyp TIMESTAMP, TIME, TIMETZ, INTERVAL YEAR TO MONTH oder INTERVAL DAY TO SECOND ausgewertet wird.
DOUBLE PRECISION, wenn der Wert *source* zum Datentyp TIMESTAMPTZ ausgewertet wird.
## Beispiele mit TIMESTAMP
Im folgenden Beispiel werden die Wochennummern für Verkäufe bestimmt, bei denen der gezahlte Preis 10 000 USD oder mehr betrug. In diesem Beispiel werden die TICKET-Daten verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
```
select salesid, extract(week from saletime) as weeknum
from sales
where pricepaid > 9999
order by 2;
salesid | weeknum
--------+---------
159073 | 6
160318 | 8
161723 | 26
```
Im folgenden Beispiel wird der Minutenwert aus einem Literal-Zeitstempel-Wert zurückgegeben.
```
select extract(minute from timestamp '2009-09-09 12:08:43');
date_part
-----------
8
```
Im folgenden Beispiel wird der Millisekundenwert aus einem Literal-Timestamp-Wert zurückgegeben.
```
select extract(ms from timestamp '2009-09-09 12:08:43.101');
date_part
-----------
101
```
## Beispiele mit TIMESTAMPTZ
Im folgenden Beispiel wird der Jahreswert aus einem Literal-Timestamptz-Wert zurückgegeben.
```
select extract(year from timestamptz '1.12.1997 07:37:16.00 PST');
date_part
-----------
1997
```
## Beispiele mit TIME
Die folgende Beispieltabelle TIME\$1TEST enthält eine Spalte TIME\$1VAL (Typ TIME) mit drei eingefügten Werten.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Im folgenden Beispiel werden die Minuten aus jedem time\$1val extrahiert.
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
Im folgenden Beispiel werden die Stunden aus jedem time\$1val extrahiert.
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
Im folgenden Beispiel wird Millisekunden aus einem Literalwert extrahiert.
```
select extract(ms from time '18:25:33.123456');
date_part
-----------
123
```
## Beispiele mit TIMETZ
Die folgende Beispieltabelle TIMETZ\$1TEST enthält eine Spalte TIMETZ\$1VAL (Typ TIMETZ) mit drei eingefügten Werten.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Im folgenden Beispiel werden die Stunden aus jedem timetz\$1val extrahiert.
```
select extract(hour from timetz_val) as hours from time_test;
hours
-----------
4
0
5
```
Im folgenden Beispiel wird Millisekunden aus einem Literalwert extrahiert. Literale werden nicht in UTC konvertiert, bevor die Extraktion verarbeitet wurde.
```
select extract(ms from timetz '18:25:33.123456 EST');
date_part
-----------
123
```
Im folgenden Beispiel wird die Stunde der Zeitzonenabweichung von UTC aus einem Literal-Timetz-Wert zurückgegeben.
```
select extract(timezone_hour from timetz '1.12.1997 07:37:16.00 PDT');
date_part
-----------
-7
```
## Beispiele mit INTERVALL YEAR TO MONTH und INTERVALL DAY TO SECOND
Im folgenden Beispiel wird der Tagesteil `1` von INTERVAL DAY TO SECOND extrahiert, der 36 Stunden definiert, d.h.1 Tag und 12 Stunden.
```
select EXTRACT('days' from INTERVAL '36 hours' DAY TO SECOND)
date_part
------------------
1
```
Im folgenden Beispiel wird der Monatsteil `3` von YEAR TO MONTH extrahiert, der 15 Monate definiert, d.h. 1 Jahr und 3 Monate.
```
select EXTRACT('month' from INTERVAL '15 months' YEAR TO MONTH)
date_part
------------------
3
```
Im folgenden Beispiel wird der Monatsteil von `6` von 30 Monaten extrahiert, was 2 Jahren und 6 Monaten entspricht.
```
select EXTRACT('month' from INTERVAL '30' MONTH)
date_part
------------------
6
```
Im folgenden Beispiel wird der Stundenteil von `2` von 50 Stunden extrahiert, was 2 Tagen und 2 Stunden entspricht.
```
select EXTRACT('hours' from INTERVAL '50' HOUR)
date_part
------------------
2
```
Im folgenden Beispiel wird der Minutenteil von `11` von 1 Stunde und 11 Minuten und 11,123 Sekunden extrahiert.
```
select EXTRACT('minute' from INTERVAL '70 minutes 70.123 seconds' MINUTE TO SECOND)
date_part
------------------
11
```
Im folgenden Beispiel wird der Sekundenanteil von `1.11` von 1 Tag und 1 Stunde und 1 Minute und 1,11 Sekunden extrahiert.
```
select EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
date_part
------------------
1.11
```
Im folgenden Beispiel wird die Gesamtzahl der Stunden in einem INTERVAL extrahiert. Jeder Teil wird extrahiert und zu einer Gesamtsumme hinzugefügt.
```
select EXTRACT('days' from INTERVAL '50' HOUR) * 24 + EXTRACT('hours' from INTERVAL '50' HOUR)
?column?
------------------
50
```
Im folgenden Beispiel wird die Gesamtzahl der Sekunden in einem INTERVAL extrahiert. Jeder Teil wird extrahiert und zu einer Gesamtsumme hinzugefügt.
```
select EXTRACT('days' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 86400 +
EXTRACT('hours' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 3600 +
EXTRACT('minutes' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 60 +
EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
?column?
------------------
90061.11
```
# Funktion GETDATE
GETDATE gibt das aktuelle Datum und die aktuelle Uhrzeit in der Zeitzone der aktuellen Sitzung (standardmäßig UTC) aus. Es gibt das Startdatum oder die Uhrzeit der aktuellen Anweisung zurück, auch wenn es sich innerhalb eines Transaktionsblocks befindet.
## Syntax
```
GETDATE()
```
Die Klammern sind erforderlich.
## Rückgabetyp
TIMESTAMP
## Beispiele
Das folgende Beispiel verwendet die Funktion GETDATE zur Rückgabe des vollständigen Zeitstempels für das aktuelle Datum.
```
select getdate();
timestamp
---------------------
2008-12-04 16:10:43
```
Das folgende Beispiel verwendet die Funktion GETDATE innerhalb der Funktion TRUNC zur Rückgabe des aktuellen Datums ohne die Uhrzeit.
```
select trunc(getdate());
trunc
------------
2008-12-04
```
# Funktion INTERVAL\$1CMP
INTERVAL\$1COMP vergleicht zwei Intervalle und gibt `1` aus, wenn das erste Intervall größer ist, `-1`, wenn das zweite Intervall größer ist, und `0`, wenn die Intervalle identisch sind. Weitere Informationen finden Sie unter [Beispiele für Intervallliterale ohne Qualifier-Syntax](r_interval_literals.md).
## Syntax
```
INTERVAL_CMP(interval1, interval2)
```
## Argumente
*interval1*
Ein Intervallliteralwert.
*interval2*
Ein Intervallliteralwert.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht den Wert `3 days` mit `1 year`.
```
select interval_cmp('3 days','1 year');
interval_cmp
--------------
-1
```
In diesem Beispiel wird der Wert `7 days` mit `1 week` verglichen.
```
select interval_cmp('7 days','1 week');
interval_cmp
--------------
0
```
Das folgende Beispiel vergleicht den Wert `1 year` mit `3 days`.
```
select interval_cmp('1 year','3 days');
interval_cmp
--------------
1
```
# Funktion LAST\$1DAY
LAST\$1DAY gibt das Datum des letzten Tages des Monats aus, der *date* enthält. Der Typ der Rückgabe ist immer DATE, unabhängig vom Typ des *date*-Arguments.
Weitere Informationen zum Abrufen spezifischer Datumsteile finden Sie unter [Funktion DATE\$1TRUNC](r_DATE_TRUNC.md).
## Syntax
```
LAST_DAY( { date | timestamp } )
```
## Argumente
*date* \$1 *timestamp*
Eine Spalte vom Datentyp `DATE` oder `TIMESTAMP` bzw. ein Ausdruck, der implizit zu einem `DATE`- oder `TIMESTAMP`-Typ ausgewertet wird.
## Rückgabetyp
DATUM
## Beispiele
Das folgende Beispiel gibt das Datum des letzten Tages des aktuellen Monats zurück.
```
select last_day(sysdate);
last_day
------------
2014-01-31
```
Das folgende Beispiel gibt die Anzahl der an jedem der letzten 7 Tage des Monats verkauften Tickets zurück. Die Werte in der Spalte SALETIME sind Zeitstempel.
```
select datediff(day, saletime, last_day(saletime)) as "Days Remaining", sum(qtysold)
from sales
where datediff(day, saletime, last_day(saletime)) < 7
group by 1
order by 1;
days remaining | sum
---------------+-------
0 | 10140
1 | 11187
2 | 11515
3 | 11217
4 | 11446
5 | 11708
6 | 10988
(7 rows)
```
# Funktion MONTHS\$1BETWEEN
MONTHS\$1BETWEEN bestimmt die Anzahl der Monate zwischen zwei Daten.
Wenn das erste Datum nach dem zweiten Datum liegt, ist das Ergebnis positiv, andernfalls ist es negativ.
Wenn eines der Argumente Null ist, ist das Ergebnis NULL.
## Syntax
```
MONTHS_BETWEEN( date1, date2 )
```
## Argumente
*date1*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
*date2*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
## Rückgabetyp
FLOAT8
Der ganzzahlige Teil des Ergebnisses basiert auf der Differenz zwischen den Jahr- und Monat-Werten der Datumsangaben. Der Bruchteil des Ergebnisses wird aus den Tag- und Zeitstempelwerten der Datumsangabe unter Zugrundelegung eines Monats mit 31 Tagen berechnet.
Wenn *date1* und *date2* beide das gleiche Datum in einem Monat (zum Beispiel 1/15/14 und 2/15/14) oder den letzten Tag des Monats (zum Beispiel 8/31/14 und 9/30/14) enthalten, ist das Ergebnis eine Ganzzahl auf der Grundlage der Jahr- und Monat-Werte der Daten, unabhängig davon, ob der Zeitstempelteil, falls vorhanden, übereinstimmt.
## Beispiele
Das folgende Beispiel gibt die Monate zwischen 1/18/1969 und 3/18/1969 zurück.
```
select months_between('1969-01-18', '1969-03-18')
as months;
months
----------
-2
```
Das folgende Beispiel gibt die Monate zwischen 18.01.1969 und 18.03.1969 zurück.
```
select months_between('1969-01-18', '1969-01-18')
as months;
months
----------
0
```
Das folgende Beispiel gibt die Monate zwischen dem ersten und der letzten Vorkommen eines Ereignisses zurück.
```
select eventname,
min(starttime) as first_show,
max(starttime) as last_show,
months_between(max(starttime),min(starttime)) as month_diff
from event
group by eventname
order by eventname
limit 5;
eventname first_show last_show month_diff
---------------------------------------------------------------------------
.38 Special 2008-01-21 19:30:00.0 2008-12-25 15:00:00.0 11.12
3 Doors Down 2008-01-03 15:00:00.0 2008-12-01 19:30:00.0 10.94
70s Soul Jam 2008-01-16 19:30:00.0 2008-12-07 14:00:00.0 10.7
A Bronx Tale 2008-01-21 19:00:00.0 2008-12-15 15:00:00.0 10.8
A Catered Affair 2008-01-08 19:30:00.0 2008-12-19 19:00:00.0 11.35
```
# Funktion NEXT\$1DAY
NEXT\$1DAY gibt das Datum der ersten Instanz des bestimmten Tages aus, der nach dem angegebenen Datum liegt.
Wenn der *day*-Wert derselbe Wochentag wie das angegebene Datum ist, wird die nächste Wiederkehr des Tages ausgegeben.
## Syntax
```
NEXT_DAY( { date | timestamp }, day )
```
## Argumente
*date* \$1 *timestamp*
Eine Spalte vom Datentyp `DATE` oder `TIMESTAMP` bzw. ein Ausdruck, der implizit zu einem `DATE`- oder `TIMESTAMP`-Typ ausgewertet wird.
*Tag*
Eine Zeichenfolge, die den Namen eines Tages enthält. Die Groß- und Kleinschreibung spielt keine Rolle.
Gültige Werte sind:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_NEXT_DAY.html)
## Rückgabetyp
DATUM
## Beispiele
Das folgende Beispiel gibt das Datum des ersten Dienstags nach 8/20/2014 aus.
```
select next_day('2014-08-20','Tuesday');
next_day
-----------
2014-08-26
```
Das folgende Beispiel gibt das Datum des ersten Dienstags nach dem 01.01.2008 um 5:54:44 zurück.
```
select listtime, next_day(listtime, 'Tue') from listing limit 1;
listtime | next_day
--------------------+-----------
2008-01-01 05:54:44 | 2008-01-08
```
Das folgende Datum ruft die Ziel-Marketingdaten für das dritte Quartal ab.
```
select username, (firstname ||' '|| lastname) as name,
eventname, caldate, next_day (caldate, 'Monday') as marketing_target
from sales, date, users, event
where sales.buyerid = users.userid
and sales.eventid = event.eventid
and event.dateid = date.dateid
and date.qtr = 3
order by marketing_target, eventname, name;
username | name | eventname | caldate | marketing_target
----------+-------------------+----------------------+--------------+-------------------
MBO26QSG | Callum Atkinson | .38 Special | 2008-07-06 | 2008-07-07
WCR50YIU | Erasmus Alvarez | A Doll's House | 2008-07-03 | 2008-07-07
CKT70OIE | Hadassah Adkins | Ana Gabriel | 2008-07-06 | 2008-07-07
VVG07OUO | Nathan Abbott | Armando Manzanero | 2008-07-04 | 2008-07-07
GEW77SII | Scarlet Avila | August: Osage County | 2008-07-06 | 2008-07-07
ECR71CVS | Caryn Adkins | Ben Folds | 2008-07-03 | 2008-07-07
KUW82CYU | Kaden Aguilar | Bette Midler | 2008-07-01 | 2008-07-07
WZE78DJZ | Kay Avila | Bette Midler | 2008-07-01 | 2008-07-07
HXY04NVE | Dante Austin | Britney Spears | 2008-07-02 | 2008-07-07
URY81YWF | Wilma Anthony | Britney Spears | 2008-07-02 | 2008-07-07
```
# Funktion SYSDATE
SYSDATE gibt das aktuelle Datum und die aktuelle Uhrzeit in der Zeitzone der aktuellen Sitzung (standardmäßig UTC) aus.
**Anmerkung**
SYSDATE gibt das Startdatum und die Uhrzeit für die aktuelle Transaktion aus, nicht für den Start der aktuellen Anweisung.
## Syntax
```
SYSDATE
```
Für diese Funktion sind keine Argumente erforderlich.
## Rückgabetyp
TIMESTAMP
## Beispiele
Das folgende Beispiel verwendet die Funktion SYSDATE zur Rückgabe des vollständigen Zeitstempels für das aktuelle Datum.
```
select sysdate;
timestamp
----------------------------
2008-12-04 16:10:43.976353
```
Das folgende Beispiel verwendet die Funktion SYSDATE innerhalb der Funktion TRUNC zur Rückgabe des aktuellen Datums ohne die Uhrzeit.
```
select trunc(sysdate);
trunc
------------
2008-12-04
```
Die folgende Abfrage gibt Vertriebsinformationen für Daten zurück, die zwischen dem Datum der Ausgabe der Abfrage und dem 120 Tage davor liegenden Datum liegen.
```
select salesid, pricepaid, trunc(saletime) as saletime, trunc(sysdate) as now
from sales
where saletime between trunc(sysdate)-120 and trunc(sysdate)
order by saletime asc;
salesid | pricepaid | saletime | now
---------+-----------+------------+------------
91535 | 670.00 | 2008-08-07 | 2008-12-05
91635 | 365.00 | 2008-08-07 | 2008-12-05
91901 | 1002.00 | 2008-08-07 | 2008-12-05
...
```
# Funktion TIMEOFDAY
TIMEOFDAY ist ein spezielles Alias zur Ausgabe von Wochentag, Datum und Uhrzeit als Zeichenfolgenwert. Es gibt die Tageszeitzeichenfolge für die aktuelle Anweisung zurück, auch wenn es sich innerhalb eines Transaktionsblocks befindet.
## Syntax
```
TIMEOFDAY()
```
## Rückgabetyp
VARCHAR
## Beispiele
Das folgende Beispiel zeugt die Ausgabe des aktuellen Datums und der Uhrzeit mit der Funktion TIMEOFDAY.
```
select timeofday();
timeofday
------------
Thu Sep 19 22:53:50.333525 2013 UTC
```
# Funktion TIMESTAMP\$1CMP
Vergleicht die Werte zweier Zeitstempel und gibt eine Ganzzahl aus. Wenn die Zeitstempel identisch sind, gibt die Funktion `0` zurück. Ist der erste Zeitstempel größer, gibt die Funktion `1` zurück. Ist der zweite Zeitstempel größer, gibt die Funktion `-1` zurück.
## Syntax
```
TIMESTAMP_CMP(timestamp1, timestamp2)
```
## Argumente
*timestamp1*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der implizit zu einem `TIMESTAMP`-Typ ausgewertet wird.
*timestamp2*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der implizit zu einem `TIMESTAMP`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht Zeitstempel und zeigt die Ergebnisse des Vergleichs.
```
SELECT TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-01-24 06:43:29'), TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-02-18 02:36:48'), TIMESTAMP_CMP('2008-02-18 02:36:48', '2008-01-24 06:43:29');
timestamp_cmp | timestamp_cmp | timestamp_cmp
---------------+---------------+---------------
0 | -1 | 1
```
Das folgende Beispiel vergleicht LISTTIME und SALETIME für eine Auflistung. Der Wert für TIMESTAMP\$1CMP ist `-1` für alle Angebote, da der Zeitstempel für den Verkauf nach dem Zeitstempel für das Angebot liegt.
```
select listing.listid, listing.listtime,
sales.saletime, timestamp_cmp(listing.listtime, sales.saletime)
from listing, sales
where listing.listid=sales.listid
order by 1, 2, 3, 4
limit 10;
listid | listtime | saletime | timestamp_cmp
--------+---------------------+---------------------+---------------
1 | 2008-01-24 06:43:29 | 2008-02-18 02:36:48 | -1
4 | 2008-05-24 01:18:37 | 2008-06-06 05:00:16 | -1
5 | 2008-05-17 02:29:11 | 2008-06-06 08:26:17 | -1
5 | 2008-05-17 02:29:11 | 2008-06-09 08:38:52 | -1
6 | 2008-08-15 02:08:13 | 2008-08-31 09:17:02 | -1
10 | 2008-06-17 09:44:54 | 2008-06-26 12:56:06 | -1
10 | 2008-06-17 09:44:54 | 2008-07-10 02:12:36 | -1
10 | 2008-06-17 09:44:54 | 2008-07-16 11:59:24 | -1
10 | 2008-06-17 09:44:54 | 2008-07-22 02:23:17 | -1
12 | 2008-07-25 01:45:49 | 2008-08-04 03:06:36 | -1
(10 rows)
```
Dieses Beispiel zeigt, dass TIMESTAMP\$1CMP für identische Zeitstempel den Wert 0 zurückgibt:
```
select listid, timestamp_cmp(listtime, listtime)
from listing
order by 1 , 2
limit 10;
listid | timestamp_cmp
--------+---------------
1 | 0
2 | 0
3 | 0
4 | 0
5 | 0
6 | 0
7 | 0
8 | 0
9 | 0
10 | 0
(10 rows)
```
# Funktion TIMESTAMP\$1CMP\$1DATE
TIMESTAMP\$1CMP\$1DATE vergleicht den Wert eines Zeitstempels mit einem Datum. Wenn die Werte von Zeitstempel und Datum identisch sind, gibt die Funktion `0` zurück. Ist der Zeitstempel chronologisch größer, gibt die Funktion `1` zurück. Ist das Datum größer, gibt die Funktion `-1` zurück.
## Syntax
```
TIMESTAMP_CMP_DATE(timestamp, date)
```
## Argumente
*timestamp*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der implizit zu einem `TIMESTAMP`-Typ ausgewertet wird.
*date*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht LISTTIME mit dem Datum `2008-06-18`. Nach diesem Datum erstellte Auflistungen geben `1` aus, davor erstellte Auflistungen `-1`. LISTTIME-Werte sind Zeitstempel.
```
select listid, listtime,
timestamp_cmp_date(listtime, '2008-06-18')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | timestamp_cmp_date
--------+---------------------+--------------------
1 | 2008-01-24 06:43:29 | -1
2 | 2008-03-05 12:25:29 | -1
3 | 2008-11-01 07:35:33 | 1
4 | 2008-05-24 01:18:37 | -1
5 | 2008-05-17 02:29:11 | -1
6 | 2008-08-15 02:08:13 | 1
7 | 2008-11-15 09:38:15 | 1
8 | 2008-11-09 05:07:30 | 1
9 | 2008-09-09 08:03:36 | 1
10 | 2008-06-17 09:44:54 | -1
(10 rows)
```
# Funktion TIMESTAMP\$1CMP\$1TIMESTAMPTZ
TIMESTAMP\$1CMP\$1TIMESTAMPTZ vergleicht den Wert eines Zeitstempelausdrucks mit einem Zeitstempelausdruck mit Zeitzone. Wenn die Werte des Zeitstempels und des Zeitstempels mit Zeitzone identisch sind, gibt die Funktion `0` zurück. Ist der Zeitstempel chronologisch größer, gibt die Funktion `1` zurück. Ist der Zeitstempel mit Zeitzone größer, gibt die Funktion `–1` zurück.
## Syntax
```
TIMESTAMP_CMP_TIMESTAMPTZ(timestamp, timestamptz)
```
## Argumente
*timestamp*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der implizit zu einem `TIMESTAMP`-Typ ausgewertet wird.
*timestamptz*
Eine Spalte vom Datentyp `TIMESTAMPTZ` oder ein Ausdruck, der implizit zu einem `TIMESTAMPTZ`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht Zeitstempel mit Zeitstempel mit Zeitzonen und zeigt die Ergebnisse des Vergleichs an.
```
SELECT TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-01-24 06:43:29+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-02-18 02:36:48+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-02-18 02:36:48', '2008-01-24 06:43:29+00');
timestamp_cmp_timestamptz | timestamp_cmp_timestamptz | timestamp_cmp_timestamptz
---------------------------+---------------------------+--------------------------
0 | -1 | 1
```
# Funktion TIMESTAMPTZ\$1CMP
TIMESTAMPTZ\$1CMP vergleicht den Wert zweier Werte von Zeitstempeln mit Zeitzone und gibt eine Ganzzahl aus. Wenn die Zeitstempel identisch sind, gibt die Funktion `0` zurück. Ist der erste Zeitstempel chronologisch größer, gibt die Funktion `1` zurück. Ist der zweite Zeitstempel größer, gibt die Funktion `–1` zurück.
## Syntax
```
TIMESTAMPTZ_CMP(timestamptz1, timestamptz2)
```
## Argumente
*timestamptz1*
Eine Spalte vom Datentyp `TIMESTAMPTZ` oder ein Ausdruck, der implizit zu einem `TIMESTAMPTZ`-Typ ausgewertet wird.
*timestamptz2*
Eine Spalte vom Datentyp `TIMESTAMPTZ` oder ein Ausdruck, der implizit zu einem `TIMESTAMPTZ`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht Zeitstempel mit Zeitzonen und zeigt die Ergebnisse des Vergleichs an.
```
SELECT TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29+00'), TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48+00'), TIMESTAMPTZ_CMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29+00');
timestamptz_cmp | timestamptz_cmp | timestamptz_cmp
-----------------+-----------------+----------------
0 | -1 | 1
```
# Funktion TIMESTAMPTZ\$1CMP\$1DATE
TIMESTAMPTZ\$1CMP\$1DATE vergleicht den Wert eines Zeitstempels mit einem Datum. Wenn die Werte von Zeitstempel und Datum identisch sind, gibt die Funktion `0` zurück. Ist der Zeitstempel chronologisch größer, gibt die Funktion `1` zurück. Ist das Datum größer, gibt die Funktion `–1` zurück.
## Syntax
```
TIMESTAMPTZ_CMP_DATE(timestamptz, date)
```
## Argumente
*timestamptz*
Eine Spalte vom Datentyp `TIMESTAMPTZ` oder ein Ausdruck, der implizit zu einem `TIMESTAMPTZ`-Typ ausgewertet wird.
*date*
Eine Spalte vom Datentyp `DATE` oder ein Ausdruck, der implizit zu einem `DATE`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Im folgenden Beispiel wird LISTTIME als Zeitstempel mit Zeitzone mit dem Datum `2008-06-18` verglichen. Nach diesem Datum erstellte Auflistungen geben `1` aus, davor erstellte Auflistungen `-1`.
```
select listid, CAST(listtime as timestamptz) as tstz,
timestamp_cmp_date(tstz, '2008-06-18')
from listing
order by 1, 2, 3
limit 10;
listid | tstz | timestamptz_cmp_date
--------+------------------------+----------------------
1 | 2008-01-24 06:43:29+00 | -1
2 | 2008-03-05 12:25:29+00 | -1
3 | 2008-11-01 07:35:33+00 | 1
4 | 2008-05-24 01:18:37+00 | -1
5 | 2008-05-17 02:29:11+00 | -1
6 | 2008-08-15 02:08:13+00 | 1
7 | 2008-11-15 09:38:15+00 | 1
8 | 2008-11-09 05:07:30+00 | 1
9 | 2008-09-09 08:03:36+00 | 1
10 | 2008-06-17 09:44:54+00 | -1
(10 rows)
```
# Funktion TIMESTAMPTZ\$1CMP\$1TIMESTAMP
TIMESTAMPTZ\$1CMP\$1TIMESTAMP vergleicht den Wert eines Zeitstempelausdrucks mit Zeitzone mit einem Zeitstempelausdruck. Wenn die Werte von Zeitstempel mit Zeitzone und Zeitstempel identisch sind, gibt die Funktion `0` zurück. Ist der Zeitstempel mit Zeitzone chronologisch größer, gibt die Funktion `1` zurück. Ist der Zeitstempel größer, gibt die Funktion `–1` zurück.
## Syntax
```
TIMESTAMPTZ_CMP_TIMESTAMP(timestamptz, timestamp)
```
## Argumente
*timestamptz*
Eine Spalte vom Datentyp `TIMESTAMPTZ` oder ein Ausdruck, der implizit zu einem `TIMESTAMPTZ`-Typ ausgewertet wird.
*timestamp*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der implizit zu einem `TIMESTAMP`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
## Beispiele
Das folgende Beispiel vergleicht Zeitstempel mit Zeitzonen mit Zeitstempel und zeigt die Ergebnisse des Vergleichs an.
```
SELECT TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29');
timestamptz_cmp_timestamp | timestamptz_cmp_timestamp | timestamptz_cmp_timestamp
---------------------------+---------------------------+---------------------------
0 | -1 | 1
```
# Funktion TIMEZONE
TIMEZONE gibt einen Zeitstempel für den angegebenen Wert eines Zeitstempels mit Zeitzone aus.
Informationen und Beispiele zum Festlegen der Zeitzone finden Sie unter [Zeitzone](r_timezone_config.md).
Informationen und Beispiele zum Konvertieren der Zeitzone finden Sie unter [CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md).
## Syntax
```
TIMEZONE('timezone', { timestamp | timestamptz })
```
## Argumente
*Zeitzone*
Die Zeitzone für den Rückgabewert. Die Zeitzone kann als Zeitzonenname (beispielsweise **'Africa/Kampala'** oder **'Singapore'**) oder als Zeitzonenabkürzung (beispielsweise **'UTC'** oder **'PDT'**) angegeben werden. Führen Sie den folgenden Befehl aus, um eine Liste der unterstützten Zeitzonennamen anzuzeigen.
```
select pg_timezone_names();
```
Führen Sie den folgenden Befehl aus, um eine Liste der unterstützten Zeitzonenabkürzungen anzuzeigen.
```
select pg_timezone_abbrevs();
```
Beachten Sie, dass Amazon Redshift die [IANA-Zeitzonendatenbank](https://www.iana.org/time-zones) als maßgebliche Quelle für die Zeitzonenspezifikation verwendet. Weitere Informationen und Beispiele finden Sie unter [Nutzungshinweise zu Zeitstempeln](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
*timestamp* \$1 *timestamptz*
Ein Ausdruck, der in einem TIMESTAMP- oder TIMESTAMPTZ-Typ oder einem Wert resultiert, der implizit zu einem Zeitstempel oder einem Zeitstempel mit Zeitzone gezwungen werden kann.
## Rückgabetyp
TIMESTAMPTZ bei Verwendung mit einem TIMESTAMP-Ausdruck.
TIMESTAMP bei Verwendung mit einem TIMESTAMPTZ-Ausdruck.
## Beispiele
Im Folgenden wird ein Zeitstempel für die UTC-Zeitzone unter Verwendung des Zeitstempels `2008-06-17 09:44:54` der PST-Zeitzone zurückgegeben.
```
SELECT TIMEZONE('PST', '2008-06-17 09:44:54');
timezone
-----------------------
2008-06-17 17:44:54+00
```
Im Folgenden wird ein Zeitstempel für die PST-Zeitzone unter Verwendung des Zeitstempels der UTC-Zeitzone `2008-06-17 09:44:54+00` zurückgegeben.
```
SELECT TIMEZONE('PST', timestamptz('2008-06-17 09:44:54+00'));
timezone
-----------------------
2008-06-17 01:44:54
```
# Funktion TO\$1TIMESTAMP
TO\$1TIMESTAMP konvertiert eine TIMESTAMP-Zeichenfolge zu TIMESTAMPTZ. Eine Liste mit zusätzlichen Datums- und Uhrzeitfunktionen für Amazon Redshift finden Sie unter [Datums- und Zeitfunktionen](Date_functions_header.md).
## Syntax
```
to_timestamp(timestamp, format)
```
```
to_timestamp (timestamp, format, is_strict)
```
## Argumente
*timestamp*
Eine Zeichenfolge, die für einen Zeitstempelwert in dem von *format* angegebenen Format steht. Wenn dieses Argument leer gelassen wird, wird der Zeitstempelwert standardmäßig auf `0001-01-01 00:00:00` gesetzt.
*format*
Ein Zeichenfolgeliteral, das das Format des *timestamp*-Werts definiert. Formate, die eine Zeitzone (**TZ**, **tz** oder **OF**) enthalten, werden als Eingabe nicht unterstützt. Für gültige Zeitstempelformate vgl. [Datum-/Uhrzeit-Formatzeichenfolgen](r_FORMAT_strings.md).
*is\$1strict*
Ein optionaler boolescher Wert, der angibt, ob ein Fehler zurückgegeben wird, wenn ein Eingabezeitstempelwert außerhalb des zulässigen Bereichs liegt. Wenn *is\$1strict* auf TRUE gesetzt wird, wird ein Fehler zurückgegeben, wenn ein Wert außerhalb des zulässigen Bereichs liegt. Wenn *is\$1strict* auf FALSE gesetzt wird, was die Standardeinstellung ist, sind Überlaufwerte zulässig.
## Rückgabetyp
TIMESTAMPTZ
## Beispiele
Das folgende Beispiel zeigt die Verwendung der Funktion TO\$1TIMESTAMP zur Konvertierung einer TIMESTAMP-Zeichenfolge in einen TIMESTAMPTZ.
```
select sysdate, to_timestamp(sysdate, 'YYYY-MM-DD HH24:MI:SS') as second;
timestamp | second
-------------------------- ----------------------
2021-04-05 19:27:53.281812 | 2021-04-05 19:27:53+00
```
Es ist möglich, den TO\$1TIMESTAMP-Teil eines Datums zu übergeben. Die übrigen Datumsteile werden auf die Standardwerte gesetzt. Die Uhrzeit ist in der Ausgabe enthalten:
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
Die folgende SQL-Anweisung konvertiert die Zeichenfolge '2011-12-18 24:38:15' in einen TIMESTAMPTZ-Wert. Das Ergebnis ist ein TIMESTAMPTZ-Wert, der auf den nächsten Tag fällt, da die Anzahl der Stunden 24 übersteigt:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
Die folgende SQL-Anweisung konvertiert die Zeichenfolge '2011-12-18 24:38:15' in einen TIMESTAMPTZ-Wert. Das Ergebnis ist ein Fehler, da der Zeitwert im Zeitstempel 24 Stunden übersteigt:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS', TRUE);
ERROR: date/time field time value out of range: 24:38:15.0
```
# Die Funktion TRUNC
Kürzt einen `TIMESTAMP` und gibt ein `DATE` zurück.
Diese Funktion kann auch eine Zahl kürzen. Weitere Informationen finden Sie unter [Die Funktion TRUNC](r_TRUNC.md).
## Syntax
```
TRUNC(timestamp)
```
## Argumente
*timestamp*
Eine Spalte vom Datentyp `TIMESTAMP` oder ein Ausdruck, der implizit zu einem `TIMESTAMP`-Typ ausgewertet wird.
Wenn ein Zeitstempelwert mit `00:00:00` als Uhrzeit zurückgegeben werden soll, wandeln Sie das Funktionsergebnis in einen `TIMESTAMP` um.
## Rückgabetyp
DATUM
## Beispiele
Im folgenden Beispiel wird der Datumsabschnitt aus dem Ergebnis der SYSDATE-Funktion zurückgegeben (die einen Zeitstempel zurückgibt).
```
SELECT SYSDATE;
+----------------------------+
| timestamp |
+----------------------------+
| 2011-07-21 10:32:38.248109 |
+----------------------------+
SELECT TRUNC(SYSDATE);
+------------+
| trunc |
+------------+
| 2011-07-21 |
+------------+
```
Im folgenden Beispiel wird die TRUNC-Funktion auf eine `TIMESTAMP`-Spalte angewendet. Der Rückgabetyp ist ein Datum.
```
SELECT TRUNC(starttime) FROM event
ORDER BY eventid LIMIT 1;
+------------+
| trunc |
+------------+
| 2008-01-25 |
+------------+
```
Das folgende Beispiel gibt einen Zeitstempelwert mit `00:00:00` als Uhrzeit zurück, indem das Ergebnis der TRUNC-Funktion in einen `TIMESTAMP` umgewandelt wird.
```
SELECT CAST((TRUNC(SYSDATE)) AS TIMESTAMP);
+---------------------+
| trunc |
+---------------------+
| 2011-07-21 00:00:00 |
+---------------------+
```
# Datumsteile für Datums- oder Zeitstempelfunktionen
Die folgende Tabelle identifiziert die Namen und Abkürzungen von Datumsteilen und Uhrzeitteilen, die als Argumente für die folgenden Funktionen verwendet werden können:
+ DATEADD
+ DATEDIFF
+ DATE\$1PART
+ EXTRACT
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_Dateparts_for_datetime_functions.html)
## Abweichungen bei den Ergebnissen mit Sekunden, Millisekunden und Mikrosekunden
Kleinere Differenzen treten auf, wenn verschiedene Datumsfunktionen Sekunden, Millisekunden oder Mikrosekunden als Datumsteile angeben:
+ Die Funktion EXTRACT gibt nur für den angegebenen Datumsteilen Ganzzahlen aus, wobei Datumsteile auf höheren und niedrigeren Ebenen ignoriert werden. Wenn der angegebene Datumsteil „Sekunden“ ist, werden Millisekunden und Mikrosekunden in dem Ergebnis nicht berücksichtigt. Wenn der angegebene Datumsteil „Millisekunden“ ist, werden Sekunden und Mikrosekunden in dem Ergebnis nicht berücksichtigt. Wenn der angegebene Datumsteil „Mikrosekunden“ ist, werden Sekunden und Millisekunden in dem Ergebnis nicht berücksichtigt.
+ Die Funktion DATE\$1PART gibt den vollständigen Sekundenteil des Zeitstempels aus, unabhängig davon, welcher Datumsteil angegeben wurde; dabei wird je nach Bedarf entweder eine Dezimal- oder eine Ganzzahl ausgegeben.
Vergleichen Sie beispielsweise die Ergebnisse der folgenden Abfragen:
```
create table seconds(micro timestamp);
insert into seconds values('2009-09-21 11:10:03.189717');
select extract(sec from micro) from seconds;
date_part
-----------
3
select date_part(sec, micro) from seconds;
pgdate_part
-------------
3.189717
```
## Anmerkungen zu CENTURY, EPOCH, DECADE und MIL
CENTURY oder CENTURIES
Amazon Redshift lässt ein CENTURY mit dem Jahr *\$1\$1\$11* beginnen und mit dem Jahr `###0` enden:
```
select extract (century from timestamp '2000-12-16 12:21:13');
date_part
-----------
20
select extract (century from timestamp '2001-12-16 12:21:13');
date_part
-----------
21
```
EPOCH
Die Amazon-Redshift-Implementierung von EPOCH ist relativ zu 1970-01-01 00:00:00.000000, unabhängig von der Zeitzone, in der sich das Cluster befindet. Möglicherweise müssen Sie die Ergebnisse um die Differenz in Stunden verschieben, je nach der Zeitzone, in der sich das Cluster befindet.
Das folgende Beispiel veranschaulicht die folgenden Schritte:
1. Erstellt eine Tabelle mit der Bezeichnung EVENT\$1EXAMPLE auf der Grundlage der Tabelle EVENT. Dieser CREATE AS-Befehl verwendet die Funktion DATE\$1PART zur Erstellung einer Datumsspalte (mit der standardmäßigen Bezeichnung PGDATE\$1PART) zur Speicherung des Epochenwerts für jedes Ereignis.
1. Wählt die Spalte und den Datentyp von EVENT\$1EXAMPLE aus PG\$1TABLE\$1DEF aus.
1. Wählt EVENTNAME, STARTTIME und PGDATE\$1PART aus der Tabelle EVENT\$1EXAMPLE aus, um die verschiedenen Datums- und Uhrzeitformate anzuzeigen.
1. Wählt EVENTNAME und STARTTIME aus EVENT EXAMPLE aus. Konvertiert Epochenwerte in PGDATE\$1PART unter Verwendung eines Intervall von 1 Sekunde zu einem Zeitstempel ohne Zeitzone und gibt die Ergebnisse in einer Spalte mit der Bezeichnung CONVERTED\$1TIMESTAMP aus.
```
create table event_example
as select eventname, starttime, date_part(epoch, starttime) from event;
select "column", type from pg_table_def where tablename='event_example';
column | type
---------------+-----------------------------
eventname | character varying(200)
starttime | timestamp without time zone
pgdate_part | double precision
(3 rows)
```
```
select eventname, starttime, pgdate_part from event_example;
eventname | starttime | pgdate_part
----------------------+---------------------+-------------
Mamma Mia! | 2008-01-01 20:00:00 | 1199217600
Spring Awakening | 2008-01-01 15:00:00 | 1199199600
Nas | 2008-01-01 14:30:00 | 1199197800
Hannah Montana | 2008-01-01 19:30:00 | 1199215800
K.D. Lang | 2008-01-01 15:00:00 | 1199199600
Spamalot | 2008-01-02 20:00:00 | 1199304000
Macbeth | 2008-01-02 15:00:00 | 1199286000
The Cherry Orchard | 2008-01-02 14:30:00 | 1199284200
Macbeth | 2008-01-02 19:30:00 | 1199302200
Demi Lovato | 2008-01-02 19:30:00 | 1199302200
select eventname,
starttime,
timestamp with time zone 'epoch' + pgdate_part * interval '1 second' AS converted_timestamp
from event_example;
eventname | starttime | converted_timestamp
----------------------+---------------------+---------------------
Mamma Mia! | 2008-01-01 20:00:00 | 2008-01-01 20:00:00
Spring Awakening | 2008-01-01 15:00:00 | 2008-01-01 15:00:00
Nas | 2008-01-01 14:30:00 | 2008-01-01 14:30:00
Hannah Montana | 2008-01-01 19:30:00 | 2008-01-01 19:30:00
K.D. Lang | 2008-01-01 15:00:00 | 2008-01-01 15:00:00
Spamalot | 2008-01-02 20:00:00 | 2008-01-02 20:00:00
Macbeth | 2008-01-02 15:00:00 | 2008-01-02 15:00:00
The Cherry Orchard | 2008-01-02 14:30:00 | 2008-01-02 14:30:00
Macbeth | 2008-01-02 19:30:00 | 2008-01-02 19:30:00
Demi Lovato | 2008-01-02 19:30:00 | 2008-01-02 19:30:00
...
```
DECADE oder DECADES
Amazon Redshift interpretiert DECADE oder DECADES DATEPART auf der Grundlage des gewöhnlichen Kalenders. Zum Beispiel: Da der gewöhnliche Kalender mit dem Jahr 1 beginnt, ist die erste Dekade (Dekade 1) 0001-01-01 bis 0009-12-31, und die zweite Dekade (Dekade 2) ist 0010-01-01 bis 0019-12-31. Beispielsweise reicht Dekade 201 von 2000-01-01 bis 2009-12-31:
```
select extract(decade from timestamp '1999-02-16 20:38:40');
date_part
-----------
200
select extract(decade from timestamp '2000-02-16 20:38:40');
date_part
-----------
201
select extract(decade from timestamp '2010-02-16 20:38:40');
date_part
-----------
202
```
MIL oder MILS
Amazon Redshift interpretiert ein MIL mit dem Beginn am ersten Tag des Jahres *\$1001* und dem Ende am letzten Tag des Jahres `#000`:
```
select extract (mil from timestamp '2000-12-16 12:21:13');
date_part
-----------
2
select extract (mil from timestamp '2001-12-16 12:21:13');
date_part
-----------
3
```