SQL - Datumsfunktionen
Die folgende Tabelle enthält eine Liste aller wichtigen Funktionen für Datum und Uhrzeit, die über SQL verfügbar sind. Es gibt verschiedene andere Funktionen, die von Ihrem RDBMS unterstützt werden. Die angegebene Liste basiert auf MySQL RDBMS.
| Sr.Nr. | Bedienungsanleitung |
|---|---|
| 1 | DATUM HINZUFÜGEN() Fügt Daten hinzu |
| 2 | ZEIT HINZUFÜGEN() Fügt Zeit hinzu |
| 3 | CONVERT_TZ () Konvertiert von einer Zeitzone in eine andere |
| 4 | CURDATE () Gibt das aktuelle Datum zurück |
| 5 | CURRENT_DATE (), CURRENT_DATE Synonyme für CURDATE () |
| 6 | CURRENT_TIME (), CURRENT_TIME Synonyme für CURTIME () |
| 7 | CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP Synonyme für JETZT () |
| 8 | CURTIME () Gibt die aktuelle Zeit zurück |
| 9 | DATE_ADD () Fügt zwei Daten hinzu |
| 10 | DATUMSFORMAT() Formatiert das Datum wie angegeben |
| 11 | DATE_SUB () Subtrahiert zwei Daten |
| 12 | DATUM() Extrahiert den Datumsteil eines Datums- oder Datums- / Uhrzeitausdrucks |
| 13 | DATEDIFF () Subtrahiert zwei Daten |
| 14 | TAG() Synonym für DAYOFMONTH () |
| 15 | TAGNAME () Gibt den Namen des Wochentags zurück |
| 16 | MONATSTAG() Gibt den Tag des Monats zurück (1-31) |
| 17 | WOCHENTAG() Gibt den Wochentagsindex des Arguments zurück |
| 18 | DAYOFYEAR () Gibt den Tag des Jahres zurück (1-366) |
| 19 | EXTRAKT Extrahiert einen Teil eines Datums |
| 20 | FROM_DAYS () Konvertiert eine Tagesnummer in ein Datum |
| 21 | FROM_UNIXTIME () Formatiert das Datum als UNIX-Zeitstempel |
| 22 | STUNDE() Extrahiert die Stunde |
| 23 | LETZTER TAG Gibt den letzten Tag des Monats für das Argument zurück |
| 24 | LOCALTIME (), LOCALTIME Synonym für JETZT () |
| 25 | LOCALTIMESTAMP, LOCALTIMESTAMP () Synonym für JETZT () |
| 26 | MAKEDATE () Erstellt ein Datum aus dem Jahr und dem Tag des Jahres |
| 27 | ZEIT SCHAFFEN ZEIT SCHAFFEN() |
| 28 | MIKROSEKUNDE() Gibt die Mikrosekunden vom Argument zurück |
| 29 | MINUTE() Gibt die Minute des Arguments zurück |
| 30 | MONAT() Geben Sie den Monat ab dem abgelaufenen Datum zurück |
| 31 | MONTHNAME () Gibt den Namen des Monats zurück |
| 32 | JETZT() Gibt das aktuelle Datum und die aktuelle Uhrzeit zurück |
| 33 | PERIOD_ADD () Fügt einem Jahr-Monat einen Zeitraum hinzu |
| 34 | PERIOD_DIFF () Gibt die Anzahl der Monate zwischen den Perioden zurück |
| 35 | QUARTAL() Gibt das Quartal von einem Datumsargument zurück |
| 36 | SEC_TO_TIME () Konvertiert Sekunden in das Format 'HH: MM: SS' |
| 37 | ZWEITE() Gibt die Sekunde zurück (0-59) |
| 38 | STR_TO_DATE () Konvertiert eine Zeichenfolge in ein Datum |
| 39 | SUBDATE () Bei Aufruf mit drei Argumenten ein Synonym für DATE_SUB () |
| 40 | SUBTIME () Subtrahiert mal |
| 41 | SYSDATE () Gibt den Zeitpunkt zurück, zu dem die Funktion ausgeführt wird |
| 42 | ZEITFORMAT() Formate als Zeit |
| 43 | TIME_TO_SEC () Gibt das in Sekunden konvertierte Argument zurück |
| 44 | ZEIT() Extrahiert den Zeitanteil des übergebenen Ausdrucks |
| 45 | TIMEDIFF () Subtrahiert die Zeit |
| 46 | TIMESTAMP () Mit einem einzigen Argument gibt diese Funktion den Datums- oder Datums- / Uhrzeitausdruck zurück. Mit zwei Argumenten die Summe der Argumente |
| 47 | TIMESTAMPADD () Fügt einem Datum / Uhrzeit-Ausdruck ein Intervall hinzu |
| 48 | TIMESTAMPDIFF () Subtrahiert ein Intervall von einem Datum / Uhrzeit-Ausdruck |
| 49 | TO_DAYS () Gibt das in Tage konvertierte Datumsargument zurück |
| 50 | UNIX_TIMESTAMP () Gibt einen UNIX-Zeitstempel zurück |
| 51 | UTC_DATE () Gibt das aktuelle UTC-Datum zurück |
| 52 | UTC_TIME () Gibt die aktuelle UTC-Zeit zurück |
| 53 | UTC_TIMESTAMP () Gibt das aktuelle UTC-Datum und die Uhrzeit zurück |
| 54 | WOCHE() Gibt die Wochennummer zurück |
| 55 | WOCHENTAG() Gibt den Wochentagsindex zurück |
| 56 | WOCHENTAG () Gibt die Kalenderwoche des Datums zurück (1-53) |
| 57 | JAHR() Gibt das Jahr zurück |
| 58 | JAHRESWOCHE () Gibt das Jahr und die Woche zurück |
ADDDATE (Datum, INTERVALL Ausdruckseinheit), ADDDATE (Ausdruck, Tage)
Beim Aufrufen mit der INTERVAL-Form des zweiten Arguments ist ADDDATE () ein Synonym für DATE_ADD (). Die zugehörige Funktion SUBDATE () ist ein Synonym für DATE_SUB (). Informationen zum Argument INTERVAL unit finden Sie in der Diskussion zu DATE_ADD ().
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1998-02-02 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1998-02-02 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Wenn MySQL mit der Tagesform des zweiten Arguments aufgerufen wird, behandelt es diese als eine ganzzahlige Anzahl von Tagen, die dem Ausdruck hinzugefügt werden sollen.
mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1998-02-02 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ADDTIME (Ausdruck1, Ausdruck2)
ADDTIME () fügt expr2 zu expr1 hinzu und gibt das Ergebnis zurück. Der Ausdruck1 ist ein Zeit- oder Datums- / Uhrzeitausdruck, während der Ausdruck2 ein Zeitausdruck ist.
mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONVERT_TZ (dt, from_tz, to_tz)
Dies konvertiert einen Datums- / Uhrzeitwert dt von der durch from_tz angegebenen Zeitzone in die durch to_tz angegebene Zeitzone und gibt den resultierenden Wert zurück. Diese Funktion gibt NULL zurück, wenn die Argumente ungültig sind.
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET') |
+---------------------------------------------------------+
| 2004-01-01 13:00:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00') |
+---------------------------------------------------------+
| 2004-01-01 22:00:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CURDATE ()
Gibt das aktuelle Datum als Wert im Format 'JJJJ-MM-TT' oder JJJJMMTT zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird.
mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE() |
+---------------------------------------------------------+
| 1997-12-15 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0 |
+---------------------------------------------------------+
| 19971215 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CURRENT_DATE und CURRENT_DATE ()
CURRENT_DATE und CURRENT_DATE () sind Synonyme für CURDATE ()
CURTIME ()
Gibt die aktuelle Zeit als Wert im Format 'HH: MM: SS' oder HHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird. Der Wert wird in der aktuellen Zeitzone ausgedrückt.
mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME() |
+---------------------------------------------------------+
| 23:50:26 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0 |
+---------------------------------------------------------+
| 235026 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CURRENT_TIME und CURRENT_TIME ()
CURRENT_TIME und CURRENT_TIME () sind Synonyme für CURTIME ().
CURRENT_TIMESTAMP und CURRENT_TIMESTAMP ()
CURRENT_TIMESTAMP und CURRENT_TIMESTAMP () sind Synonyme für NOW ().
DATUM (Ausdruck)
Extrahiert den Datumsteil des Datums- oder Datums- / Uhrzeitausdrucks Ausdruck.
mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03') |
+---------------------------------------------------------+
| 2003-12-31 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DATEDIFF (Ausdruck1, Ausdruck2)
DATEDIFF () gibt expr1 zurück. Ausdruck2 ausgedrückt als Wert in Tagen von einem Datum zum anderen. Sowohl Ausdruck1 als auch Ausdruck2 sind Datums- oder Datums- und Uhrzeitausdrücke. Bei der Berechnung werden nur die Datumsteile der Werte verwendet.
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DATE_ADD (Datum, INTERVAL-Ausdruckseinheit), DATE_SUB (Datum, INTERVAL-Ausdruckseinheit)
Diese Funktionen führen eine Datumsarithmetik durch. Dasdateist ein DATETIME- oder DATE-Wert, der das Startdatum angibt. Dasexprist ein Ausdruck, der den Intervallwert angibt, der vom Startdatum addiert oder subtrahiert werden soll. Der Ausdruck ist eine Zeichenfolge; es kann mit einem '-' für negative Intervalle beginnen.
EIN unit ist ein Schlüsselwort, das die Einheiten angibt, in denen der Ausdruck interpretiert werden soll.
Das INTERVAL Das Schlüsselwort und der Einheitenspezifizierer unterscheiden nicht zwischen Groß- und Kleinschreibung.
Die folgende Tabelle zeigt die erwartete Form des expr-Arguments für jeden Einheitswert.
| Einheit Wert | Erwartetes exprFormat |
|---|---|
| MIKROSEKUNDE | MIKROSECONDS |
| ZWEITE | SEKUNDEN |
| MINUTE | PROTOKOLL |
| STUNDE | STD |
| TAG | TAGE |
| WOCHE | WOCHEN |
| MONAT | MONATE |
| QUARTAL | Viertel |
| JAHR | JAHRE |
| SECOND_MICROSECOND | 'SECONDS.MICROSECONDS' |
| MINUTE_MICROSECOND | 'MINUTES.MICROSECONDS' |
| MINUTE_SECOND | "MINUTEN: SEKUNDEN" |
| HOUR_MICROSECOND | 'HOURS.MICROSECONDS' |
| HOUR_SECOND | "STUNDEN: MINUTEN: SEKUNDEN" |
| HOUR_MINUTE | "STUNDEN: MINUTEN" |
| DAY_MICROSECOND | 'DAYS.MICROSECONDS' |
| DAY_SECOND | "TAGE STUNDEN: MINUTEN: SEKUNDEN" |
| DAY_MINUTE | "TAGE STUNDEN: MINUTEN" |
| DAY_HOUR | "TAGE STUNDEN" |
| JAHR MONAT | "JAHRE-MONATE" |
Die Werte QUARTER und WEEKsind in MySQL 5.0.0 verfügbar. Ausführung.
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL... |
+---------------------------------------------------------+
| 1998-01-01 00:01:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR) |
+---------------------------------------------------------+
| 1999-01-01 01:00:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DATE_FORMAT (Datum, Format)
Dieser Befehl formatiert den Datumswert gemäß der Formatzeichenfolge.
Die folgenden Bezeichner können in der Formatzeichenfolge verwendet werden. Das Zeichen '%' ist vor den Formatbezeichnerzeichen erforderlich.
| Sr.Nr. | Spezifizierer & Beschreibung |
|---|---|
| 1 | %a Abgekürzter Wochentagsname (Sun..Sat) |
| 2 | %b Abgekürzter Monatsname (Jan..Dec) |
| 3 | %c Monat, numerisch (0..12) |
| 4 | %D Tag des Monats mit englischem Suffix (0., 1., 2., 3.,.) |
| 5 | %d Tag des Monats, numerisch (00..31) |
| 6 | %e Tag des Monats, numerisch (0..31) |
| 7 | %f Mikrosekunden (000000..999999) |
| 8 | %H Stunde (00..23) |
| 9 | %h Stunde (01..12) |
| 10 | %I Stunde (01..12) |
| 11 | %i Minuten, numerisch (00..59) |
| 12 | %j Tag des Jahres (001..366) |
| 13 | %k Stunde (0..23) |
| 14 | %l Stunde (1..12) |
| 15 | %M Monatsname (Januar..Dezember) |
| 16 | %m Monat, numerisch (00..12) |
| 17 | %p Vormittags oder nachmittags |
| 18 | %r Zeit 12 Stunden (hh: mm: ss gefolgt von AM oder PM) |
| 19 | %S Sekunden (00..59) |
| 20 | %s Sekunden (00..59) |
| 21 | %T Zeit, 24 Stunden (hh: mm: ss) |
| 22 | %U Woche (00..53), wobei Sonntag der erste Tag der Woche ist |
| 23 | %u Woche (00..53), wobei Montag der erste Tag der Woche ist |
| 24 | %V Woche (01..53), wobei Sonntag der erste Tag der Woche ist; verwendet mit% X. |
| 25 | %v Woche (01..53), wobei Montag der erste Tag der Woche ist; verwendet mit% x |
| 26 | %W Wochentagsname (Sonntag..Samstag) |
| 27 | %w Wochentag (0 = Sonntag..6 = Samstag) |
| 28 | %X Jahr für die Woche, in der Sonntag der erste Tag der Woche ist, numerisch, vierstellig; verwendet mit% V. |
| 29 | %x Jahr für die Woche, wobei Montag der erste Tag der Woche ist, numerisch, vierstellig; verwendet mit% v |
| 30 | %Y Jahr, numerisch, vierstellig |
| 31 | %y Jahr, numerisch (zweistellig) |
| 32 | %% Ein wörtliches%. Charakter |
| 33 | %x x, für any.x. oben nicht aufgeführt |
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y') |
+---------------------------------------------------------+
| Saturday October 1997 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
-> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00....... |
+---------------------------------------------------------+
| 22 22 10 10:23:00 PM 22:23:00 00 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DATE_SUB (Datum, INTERVAL Ausdruckseinheit)
Dies ähnelt der Funktion DATE_ADD ().
TAG (Datum)
Das DAY () ist ein Synonym für die Funktion DAYOFMONTH ().
TAGNAME (Datum)
Gibt den Namen des Wochentags für das Datum zurück.
mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05') |
+---------------------------------------------------------+
| Thursday |
+---------------------------------------------------------+
1 row in set (0.00 sec)DAYOFMONTH (Datum)
Gibt den Tag des Monats für das Datum im Bereich von 0 bis 31 zurück.
mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DAYOFWEEK (Datum)
Gibt den Wochentagsindex für das Datum zurück (1 = Sonntag, 2 = Montag,., 7 = Samstag). Diese Indexwerte entsprechen dem ODBC-Standard.
mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DAYOFYEAR (Datum)
Gibt den Tag des Jahres für das Datum im Bereich von 1 bis 366 zurück.
mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03') |
+---------------------------------------------------------+
| 34 |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXTRAKT (Einheit AB Datum)
Die EXTRACT () -Funktion verwendet die gleichen Arten von Einheitenspezifizierern wie DATE_ADD () oder DATE_SUB (), extrahiert jedoch Teile aus dem Datum, anstatt eine Datumsarithmetik durchzuführen.
mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02') |
+---------------------------------------------------------+
| 1999 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03') |
+---------------------------------------------------------+
| 199907 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FROM_DAYS (N)
Gibt bei einer Tagesnummer N einen DATE-Wert zurück.
mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669) |
+---------------------------------------------------------+
| 1997-10-07 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Note- Verwenden Sie FROM_DAYS () mit Vorsicht bei alten Daten. Es ist nicht zur Verwendung mit Werten vorgesehen, die dem Aufkommen des Gregorianischen Kalenders (1582) vorausgehen.
FROM_UNIXTIME (unix_timestamp)
FROM_UNIXTIME (unix_timestamp, Format)
Gibt eine Darstellung des zurück unix_timestampArgument als Wert im Format 'JJJJ-MM-TT HH: MM: SS oder JJJJMMTTHHMMSS, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird. Der Wert wird in der aktuellen Zeitzone ausgedrückt. Das Argument unix_timestamp ist ein interner Zeitstempelwert, der von der erzeugt wirdUNIX_TIMESTAMP() Funktion.
Wenn das Format angegeben ist, wird das Ergebnis gemäß der Formatzeichenfolge formatiert, die auf die gleiche Weise verwendet wird, wie sie im Eintrag für aufgeführt ist DATE_FORMAT() Funktion.
mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580) |
+---------------------------------------------------------+
| 1997-10-04 22:23:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)STUNDE (Zeit)
Gibt die Stunde für die Zeit zurück. Der Bereich des Rückgabewerts liegt bei Tageszeitwerten zwischen 0 und 23. Der Bereich der TIME-Werte ist jedoch tatsächlich viel größer, sodass HOUR Werte größer als 23 zurückgeben kann.
mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03') |
+---------------------------------------------------------+
| 10 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LAST_DAY (Datum)
Nimmt einen Datums- oder Datums- / Uhrzeitwert und gibt den entsprechenden Wert für den letzten Tag des Monats zurück. Gibt NULL zurück, wenn das Argument ungültig ist.
mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05') |
+---------------------------------------------------------+
| 2003-02-28 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOCALTIME und LOCALTIME ()
LOCALTIME und LOCALTIME () sind Synonyme für NOW ().
LOCALTIMESTAMP und LOCALTIMESTAMP ()
LOCALTIMESTAMP und LOCALTIMESTAMP () sind Synonyme für NOW ().
MAKEDATE (Jahr, Tag des Jahres)
Gibt ein Datum mit den angegebenen Werten für Jahr und Tag zurück. Der Tageswert muss größer als 0 sein, sonst ist das Ergebnis NULL.
mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32) |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01' |
+---------------------------------------------------------+
1 row in set (0.00 sec)MAKETIME (Stunde, Minute, Sekunde)
Gibt einen Zeitwert zurück, der aus den Argumenten Stunde, Minute und Sekunde berechnet wird.
mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30) |
+---------------------------------------------------------+
| '12:15:30' |
+---------------------------------------------------------+
1 row in set (0.00 sec)MIKROSEKUNDE (Ausdruck)
Gibt die Mikrosekunden vom Zeit- oder Datums- / Uhrzeitausdruck (Ausdruck) als Zahl im Bereich von 0 bis 999999 zurück.
mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456') |
+---------------------------------------------------------+
| 123456 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MINUTE (Zeit)
Gibt die Zeitminute im Bereich von 0 bis 59 zurück.
mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03') |
+---------------------------------------------------------+
| 5 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Monatsdatum)
Gibt den Monat für das Datum im Bereich von 0 bis 12 zurück.
mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MONTHNAME (Datum)
Gibt den vollständigen Namen des Monats für ein Datum zurück.
mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05') |
+---------------------------------------------------------+
| February |
+---------------------------------------------------------+
1 row in set (0.00 sec)JETZT()
Gibt das aktuelle Datum und die aktuelle Uhrzeit als Wert im Format 'JJJJ-MM-TT HH: MM: SS' oder JJJJMMTTHHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder einem numerischen Kontext verwendet wird. Dieser Wert wird in der aktuellen Zeitzone ausgedrückt.
mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW() |
+---------------------------------------------------------+
| 1997-12-15 23:50:26 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PERIOD_ADD (P, N)
Fügt einem Zeitraum P N Monate hinzu (im Format JJJM oder JJJJMM). Gibt einen Wert im Format JJJJMM zurück. Beachten Sie, dass das Periodenargument P kein Datumswert ist.
mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2) |
+---------------------------------------------------------+
| 199803 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PERIOD_DIFF (P1, P2)
Gibt die Anzahl der Monate zwischen den Perioden P1 und P2 zurück. Diese Zeiträume P1 und P2 sollten das Format JJMM oder JJJJMM haben. Beachten Sie, dass die Periodenargumente P1 und P2 keine Datumswerte sind.
mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703) |
+---------------------------------------------------------+
| 11 |
+---------------------------------------------------------+
1 row in set (0.00 sec)QUARTAL (Datum)
Gibt das Quartal des Datumsquartals im Bereich von 1 bis 4 zurück.
mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Zweites Mal)
Gibt die Sekunde für die Zeit im Bereich von 0 bis 59 zurück.
mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SEC_TO_TIME (Sekunden)
Gibt das in Stunden, Minuten und Sekunden konvertierte Sekundenargument als Wert im Format 'HH: MM: SS' oder HHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder einem numerischen Kontext verwendet wird.
mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378) |
+---------------------------------------------------------+
| 00:39:38 |
+---------------------------------------------------------+
1 row in set (0.00 sec)STR_TO_DATE (str, format)
Dies ist die Umkehrung der Funktion DATE_FORMAT (). Es werden ein String-Str und ein Format-String-Format verwendet. Die Funktion STR_TO_DATE () gibt einen DATETIME-Wert zurück, wenn die Formatzeichenfolge sowohl Datums- als auch Zeitteile enthält. Andernfalls wird ein DATE- oder TIME-Wert zurückgegeben, wenn die Zeichenfolge nur Datums- oder Zeitteile enthält.
mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y') |
+---------------------------------------------------------+
| 2004-04-31 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBDATE (Datum, INTERVALL expr Einheit) und SUBDATE (expr, Tage)
Beim Aufrufen mit der INTERVAL-Form des zweiten Arguments ist SUBDATE () ein Synonym für DATE_SUB (). Informationen zum Argument INTERVAL unit finden Sie in der Diskussion zu DATE_ADD ().
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1997-12-02 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1997-12-02 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBTIME (Ausdruck1, Ausdruck2)
Die Funktion SUBTIME () gibt expr1 zurück. Ausdruck2 ausgedrückt als Wert im gleichen Format wie Ausdruck1. Der expr1-Wert ist ein Zeit- oder ein datetime-Ausdruck, während der expr2-Wert ein Zeitausdruck ist.
mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
-> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'... |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SYSDATE ()
Gibt das aktuelle Datum und die aktuelle Uhrzeit als Wert im Format 'JJJJ-MM-TT HH: MM: SS' oder JJJJMMTTHHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird.
mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE() |
+---------------------------------------------------------+
| 2006-04-12 13:47:44 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ZEIT (Ausdruck)
Extrahiert den Zeitteil des Zeit- oder Datums- / Uhrzeitausdrucks expr und gibt es als Zeichenfolge zurück.
mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03') |
+---------------------------------------------------------+
| 01:02:03 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIMEDIFF (Ausdruck1, Ausdruck2)
Die Funktion TIMEDIFF () gibt expr1 zurück. Ausdruck2 ausgedrückt als Zeitwert. Diese expr1- und expr2-Werte sind Zeit- oder Datums- und Zeitausdrücke, aber beide müssen vom gleichen Typ sein.
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
-> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'..... |
+---------------------------------------------------------+
| 46:58:57.999999 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIMESTAMP (Ausdruck), TIMESTAMP (Ausdruck1, Ausdruck2)
Mit einem einzigen Argument gibt diese Funktion den Datums- oder Datums- / Uhrzeitausdruck expr als Datums- / Uhrzeitwert zurück. Mit zwei Argumenten wird der Uhrzeitausdruck expr2 zum Datums- oder Datums- / Uhrzeitausdruck hinzugefügtexpr1 und gibt das Ergebnis als Datum / Uhrzeit-Wert zurück.
mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31') |
+---------------------------------------------------------+
| 2003-12-31 00:00:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIMESTAMPADD (Einheit, Intervall, datetime_expr)
Diese Funktion fügt dem Datums- oder Datums- / Uhrzeitausdruck das Intervall für ganzzahlige Ausdrücke hinzu datetime_expr. Die Einheit für das Intervall wird durch das Einheitsargument angegeben, das einer der folgenden Werte sein sollte:
- FRAC_SECOND
- ZWEITE, MINUTE
- STUNDE, TAG
- WEEK
- MONTH
- QUARTAL oder
- YEAR
Der Einheitswert kann mit einem der gezeigten Schlüsselwörter oder mit dem Präfix SQL_TSI_ angegeben werden.
Zum Beispiel sind DAY und SQL_TSI_DAY beide legal.
mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02') |
+---------------------------------------------------------+
| 2003-01-02 00:01:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIMESTAMPDIFF (Einheit, datetime_expr1, datetime_expr2)
Gibt die ganzzahlige Differenz zwischen den Datums- oder Datums- / Uhrzeitausdrücken datetime_expr1 und datetime_expr2 zurück. Die Einheit für das Ergebnis wird durch das Einheitsargument angegeben. Die zulässigen Werte für das Gerät entsprechen denen, die in der Beschreibung der Funktion TIMESTAMPADD () aufgeführt sind.
mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIME_FORMAT (Zeit, Format)
Diese Funktion wird wie die Funktion DATE_FORMAT () verwendet, die Formatzeichenfolge kann jedoch Formatspezifizierer nur für Stunden, Minuten und Sekunden enthalten.
Wenn der Zeitwert einen Stundenanteil enthält, der größer als 23 ist, wird der%H und %k Stundenformatspezifizierer erzeugen einen Wert, der größer als der übliche Bereich von 0 bis 23 ist. Die anderen Stundenformatspezifizierer erzeugen den Stundenwert modulo 12.
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l') |
+---------------------------------------------------------+
| 100 100 04 04 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIME_TO_SEC (Zeit)
Gibt das in Sekunden konvertierte Zeitargument zurück.
mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00') |
+---------------------------------------------------------+
| 80580 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Heutiges Datum)
Gibt bei einem bestimmten Datum eine Tagesnummer zurück (die Anzahl der Tage seit dem Jahr 0).
mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501) |
+---------------------------------------------------------+
| 728779 |
+---------------------------------------------------------+
1 row in set (0.00 sec)UNIX_TIMESTAMP (), UNIX_TIMESTAMP (Datum)
Wenn diese Funktion ohne Argument aufgerufen wird, gibt sie einen Unix-Zeitstempel (Sekunden seit '1970-01-01 00:00:00' UTC) als vorzeichenlose Ganzzahl zurück. Wenn UNIX_TIMESTAMP () mit einem Datumsargument aufgerufen wird, wird der Wert des Arguments als Sekunden seit '1970-01-01 00:00:00' UTC zurückgegeben. Datum kann eine DATE-Zeichenfolge, eine DATETIME-Zeichenfolge, ein TIMESTAMP oder eine Zahl im Format JJJMTT oder JJJJMMTT sein.
mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP() |
+---------------------------------------------------------+
| 882226357 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00') |
+---------------------------------------------------------+
| 875996580 |
+---------------------------------------------------------+
1 row in set (0.00 sec)UTC_DATE, UTC_DATE ()
Gibt das aktuelle UTC-Datum als Wert im Format 'JJJJ-MM-TT' oder JJJJMMTT zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder einem numerischen Kontext verwendet wird.
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0 |
+---------------------------------------------------------+
| 2003-08-14, 20030814 |
+---------------------------------------------------------+
1 row in set (0.00 sec)UTC_TIME, UTC_TIME ()
Gibt die aktuelle UTC-Zeit als Wert im Format 'HH: MM: SS' oder HHMMSS zurück, je nachdem, ob die Funktion in einem String- oder einem numerischen Kontext verwendet wird.
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0 |
+---------------------------------------------------------+
| 18:07:53, 180753 |
+---------------------------------------------------------+
1 row in set (0.00 sec)UTC_TIMESTAMP, UTC_TIMESTAMP ()
Gibt das aktuelle UTC-Datum und die aktuelle UTC-Uhrzeit als Wert in 'JJJJ-MM-TT HH: MM: SS' oder in einem JJJJMMTTHHMMSS-Format zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird.
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0 |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804 |
+---------------------------------------------------------+
1 row in set (0.00 sec)WOCHE (Datum [, Modus])
Diese Funktion gibt die Wochennummer für das Datum zurück. Mit der Zwei-Argument-Form von WEEK () können Sie angeben, ob die Woche an einem Sonntag oder einem Montag beginnt und ob der Rückgabewert im Bereich von 0 bis 53 oder von 1 bis 53 liegen soll. Wenn das Argument mode weggelassen wird, Der Wert der Systemvariablen default_week_format wird verwendet
| Modus | Erster Tag der Woche | Angebot | Woche 1 ist die erste Woche. |
|---|---|---|---|
| 0 | Sonntag | 0-53 | mit einem Sonntag in diesem Jahr |
| 1 | Montag | 0-53 | mit mehr als 3 Tagen in diesem Jahr |
| 2 | Sonntag | 1-53 | mit einem Sonntag in diesem Jahr |
| 3 | Montag | 1-53 | mit mehr als 3 Tagen in diesem Jahr |
| 4 | Sonntag | 0-53 | mit mehr als 3 Tagen in diesem Jahr |
| 5 | Montag | 0-53 | mit einem Montag in diesem Jahr |
| 6 | Sonntag | 1-53 | mit mehr als 3 Tagen in diesem Jahr |
| 7 | Montag | 1-53 | mit einem Montag in diesem Jahr |
mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20') |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)WOCHENTAG (Datum)
Gibt den Wochentagsindex für das Datum zurück (0 = Montag, 1 = Dienstag ,. 6 = Sonntag).
mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)WOCHENTAG (Datum)
Gibt die Kalenderwoche des Datums als Zahl im Bereich von 1 bis 53 zurück. WEEKOFYEAR () ist eine Kompatibilitätsfunktion, die WEEK (Datum, 3) entspricht.
mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20') |
+---------------------------------------------------------+
| 8 |
+---------------------------------------------------------+
1 row in set (0.00 sec)JAHR (Datum)
Gibt das Jahr für das Datum im Bereich von 1000 bis 9999 oder 0 für die Null zurück. Datum.
mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03') |
+---------------------------------------------------------+
| 1998 |
+---------------------------------------------------------+
1 row in set (0.00 sec)YEARWEEK (Datum), YEARWEEK (Datum, Modus)
Gibt das Jahr und die Woche für ein Datum zurück. Das Modusargument funktioniert genau wie das Modusargument für die Funktion WEEK (). Das Jahr im Ergebnis kann sich vom Datum im Datumsargument für die erste und die letzte Woche des Jahres unterscheiden.
mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01') |
+---------------------------------------------------------+
| 198653 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Note - Die Wochennummer unterscheidet sich von der Funktion, die die Funktion WEEK () für optionale Argumente 0 oder 1 zurückgeben würde (0), da WEEK () dann die Woche im Kontext des angegebenen Jahres zurückgibt.