Gibt es eine Möglichkeit, Millisekunden aus einem Zeitstempel in MySql
oder PostgreSql
(oder anderen nur aus Neugier) herauszuholen?
SELECT CURRENT_TIMESTAMP
--> 2012-03-08 20:12:06.032572
Gibt es so etwas:
SELECT CURRENT_MILLISEC
--> 1331255526000
oder die einzige alternative ist die DATEDIFF
aus dem era
?
CURTIME(3)
Unterstützt keine DB auchNOW(3)
? SoCONCAT(DATE(NOW()), ' ', CURTIME(3))
könnte es seinNOW(3)
, zumindest in MySQL 5.6.4+ auch,FROM_UNIXTIME
undUNIX_TIMESTAMP
sind invers zueinander, soFROM_UNIXTIME( UNIX_TIMESTAMP( whatever ) )
ergibt sichwhatever
. Ist dein langer Ausdruck nicht der gleiche wieNOW(3)
?Antworten:
So erhalten Sie den Unix-Zeitstempel in Sekunden in MySQL:
select UNIX_TIMESTAMP();
Details: http://dev.mysql.com/doc/refman/5.5/de/date-and-time-functions.html#function_unix-timestamp
Nicht getestet PostgreSQL, aber laut dieser Website sollte es funktionieren: http://www.raditha.com/postgres/timestamp.php
select round( date_part( 'epoch', now() ) );
quelle
Für MySQL (5.6+) können Sie dies tun:
SELECT ROUND(UNIX_TIMESTAMP(CURTIME(4)) * 1000)
Welches wird zurückkehren (zB):
1420998416685 --milliseconds
quelle
In MySQL ist es möglich, die UUID-Funktion zum Extrahieren von Millisekunden zu verwenden.
select conv( concat( substring(uid,16,3), substring(uid,10,4), substring(uid,1,8)) ,16,10) div 10000 - (141427 * 24 * 60 * 60 * 1000) as current_mills from (select uuid() uid) as alias;
Ergebnis:
+---------------+ | current_mills | +---------------+ | 1410954031133 | +---------------+
Es funktioniert auch in älteren MySQL-Versionen!
Vielen Dank an diese Seite: http://rpbouman.blogspot.com.es/2014/06/mysql-extracting-timstamp-and-mac.html
quelle
SELECT SUBSTR( CONV( CONCAT( SUBSTR(uid,16,3), SUBSTR(uid,10,4), SUBSTR(uid,1,8)), 16, 10) DIV 10, -6) FROM (SELECT UUID() AS uid) AS alias;
Das Hauptmissverständnis in MySQL mit Zeitstempeln besteht darin, dass MySQL standardmäßig Zeitstempel ohne Bruchteil zurückgibt und speichert .
SELECT current_timestamp() => 2018-01-18 12:05:34
die in Sekunden Zeitstempel als konvertiert werden kann
SELECT UNIX_TIMESTAMP(current_timestamp()) => 1516272429
So fügen Sie einen Bruchteil hinzu:
SELECT current_timestamp(3) => 2018-01-18 12:05:58.983
die in Mikrosekunden Zeitstempel als konvertiert werden kann
SELECT CAST( 1000*UNIX_TIMESTAMP(current_timestamp(3)) AS UNSIGNED INTEGER) ts => 1516272274786
Es gibt nur wenige Tricks beim Speichern in Tabellen. Wenn Ihre Tabelle wie erstellt wurde
CREATE TABLE `ts_test_table` ( `id` int(1) NOT NULL, `not_fractional_timestamp` timestamp NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
als MySQL wird NICHT Bruchteil darin speichern:
Wenn Sie Ihrer Tabelle einen Bruchteil hinzufügen möchten, müssen Sie Ihre Tabelle auf andere Weise erstellen:
CREATE TABLE `ts_test_table2` ( `id` int(1) NOT NULL, `some_data` varchar(10) COLLATE utf8mb4_unicode_ci NOT NULL, `fractional_timestamp` timestamp(3) NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3), PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
das führt zum gewünschten Ergebnis:
Die Funktion current_timestamp () darf Werte bis zu 6 empfangen, aber ich habe herausgefunden (zumindest in meiner unter Windows installierten MySQL 5.7.11-Version), dass die Bruchgenauigkeit 6 zu demselben konstanten Wert von 3 Stellen am Ende führt. in meinem Fall 688
Das bedeutet, dass die wirklich nutzbare Zeitstempelgenauigkeit von MySQL plattformabhängig ist:
quelle
In MySQL 5.7+ können Sie ausführen
select current_timestamp(6)
für mehr Details
https://dev.mysql.com/doc/refman/5.7/en/fractional-seconds.html
quelle
current_timestamp
ein Synonym fürnow
,now(6)
ist also ein kürzerer Weg, um diesen Wert zu erhalten.Die richtige Methode zum Extrahieren von Millisekunden aus einem Zeitstempelwert in PostgreSQL gemäß der aktuellen Dokumentation ist:
SELECT date_part('milliseconds', current_timestamp); --OR SELECT EXTRACT(MILLISECONDS FROM current_timestamp);
mit Rückgabe: Das Sekundenfeld, einschließlich Bruchteilen, multipliziert mit 1000. Beachten Sie, dass dies volle Sekunden enthält.
quelle
Verwenden:
Select curtime(4);
Dies gibt Ihnen Millisekunden.
quelle
Poster fragt nach einem ganzzahligen Wert von MS seit Epoche , nicht nach einer Zeit oder S seit Epoche.
Dazu müssen Sie verwenden
NOW(3)
, was Ihnen Zeit in Bruchteilen von Sekunden auf 3 Dezimalstellen (dh MS-Genauigkeit) gibt: 2020-02-13 16: 30: 18.236Dann
UNIX_TIMESTAMP(NOW(3))
, um die Zeit in Sekundenbruchteilen seit Epoc zu erhalten : 1581611418.236Zum Schluss
FLOOR(UNIX_TIMESTAMP(NOW(3))*1000)
noch eine schöne runde Ganzzahl für ms seit epoc: 1581611418236Machen Sie es zu einer MySQL-Funktion:
CREATE FUNCTION UNIX_MS() RETURN BIGINT DETERMINISTIC BEGIN RETURN FLOOR(UNIX_TIMESTAMP(NOW(3))*1000); END
Jetzt renn
SELECT UNIX_MS();
Hinweis: Dies wurde alles von Hand kopiert. Wenn es also Fehler gibt, können Sie diese gerne beheben.
quelle
In PostgreSQL können Sie Folgendes verwenden:
SELECT extract(epoch from now());
auf MySQL:
SELECT unix_timestamp(now());
quelle
Keine dieser Antworten löst das Problem in postgreSQL wirklich , dh:
Ich hatte das gleiche Problem und testete die verschiedenen vorherigen Antworten ohne zufriedenstellendes Ergebnis.
Schließlich fand ich einen wirklich einfachen Weg, wahrscheinlich den einfachsten:
SELECT (EXTRACT (EPOCH FROM <date_column>::timestamp)::float*1000 as unix_tms FROM <table>
nämlich:
quelle
Hier ist ein Ausdruck, der für MariaDB und MySQL funktioniert> = 5.6:
SELECT (UNIX_TIMESTAMP(NOW()) * 1000000 + MICROSECOND(NOW(6))) AS unix_now_in_microseconds;
Dies beruht auf der Tatsache, dass NOW () während einer Abfrage immer dieselbe Zeit zurückgibt . Es ist möglich, dass eine Ebene
UNIX_TIMESTAMP()
auch funktioniert. Ich bin mir aufgrund der Dokumentation nicht sicher . Für das neue Genauigkeitsargument für dieNOW()
Funktion ist außerdem MySQL> = 5.6 erforderlich (MariaDB funktioniert auch).quelle
UNIX_TIMESTAMP(NOW())
wird am Ende der Sommerzeit für eine Stunde falsch sein, wenn Sie sich in einer Sommerzeitzone befinden. Verwenden SieUNIX_TIMESTAMP()
stattdessen einfach und die Antwort funktioniert, obwohl ich nicht 100% sicher bin, was während der Schaltsekunden passiert.Der einfachste Weg, die aktuelle Zeit in Millisekunden in MySql zu erhalten:
SELECT (UNIX_TIMESTAMP(NOW(3)) * 1000)
Seit MySql 5.6.
quelle
.000
anstelle einer Ganzzahl eine Dezimalzahl zurückgegeben wird .In MariaDB können Sie verwenden
SELECT NOW(4);
Milisecs bekommen. Siehe auch hier .
quelle
Für MySQL:
SELECT (UNIX_TIMESTAMP() * 1000) AS unix_now_in_microseconds; --- 1600698677000
quelle
Ich hatte das Bedürfnis, weiter zu verfeinern, also in MySQL:
Aktueller Zeitstempel in Millisekunden:
Zeitstempel in Millisekunden ab gegebener Datumszeit (3):
Zeitstempel in Millisekunden in Datum / Uhrzeit konvertieren (3):
Konvertieren Sie datetime (3) in Millisekunden in einen Zeitstempel:
quelle
UNIX_TIMESTAMP()*1000+FLOOR(MICROSECONDS(UTC_TIME(3))*0.001)
In PostgreSQL verwenden wir diesen Ansatz:
SELECT round(EXTRACT (EPOCH FROM now())::float*1000)
quelle
Für alle hier, hören / lesen Sie einfach die Kommentare von Doin sehr gut! Die
UNIX_TIMESTAMP()
Funktion kontaktiert, wenn eine Datenzeitzeichenfolge angegeben wird, eine Ortszeit basierend auf der Zeitzone der MySQL-Verbindung oder des Servers mit einem Unix-Zeitstempel. Wenn Sie sich in einer anderen Zeitzone befinden und eine Stunde pro Jahr mit Sommerzeit zu tun haben, wird dies schief gehen!In den Niederlanden wird beispielsweise am letzten Sonntag im Oktober, eine Sekunde nach dem ersten Erreichen von 02:59:59, die Zeit wieder auf 02:00:00 zurückgesetzt. Wenn Sie die
NOW()
,CURTIME()
oderSYSDATE()
-Funktionen von MySQL verwenden und an dieUNIX_TIMESTAMP()
Funktion übergeben, sind die Zeitstempel für eine ganze Zeit falsch.Am 27. Oktober 2018 in Satudray waren Zeit und Zeitstempel beispielsweise wie folgt:
Local time | UTC Time | Timestamp | Timestamp using MYSQL's UNIX_TIMESTAMP(NOW(4)) ----------------------------------+---------------------------+--------------+----------------------------------------------------- 2018-10-27 01:59:59 CET (+02:00) | 2018-10-26 23:59:59 UTC | 1540598399 | 1540598399 2018-10-27 02:00:00 CET (+02:00) | 2018-10-27 00:00:00 UTC | 1540598400 | 1540598400 + 1 second 2018-10-27 02:59:59 CET (+02:00) | 2018-10-27 00:59:59 UTC | 1540601999 | 1540601999 2018-10-27 03:00:00 CET (+02:00) | 2018-10-27 01:00:00 UTC | 1540602000 | 1540602000 + 1 second 2018-10-27 03:59:59 CET (+02:00) | 2018-10-27 01:59:59 UTC | 1540605599 | 1540605599 2018-10-27 04:00:00 CET (+02:00) | 2018-10-27 02:00:00 UTC | 1540605600 | 1540605600 + 1 second
Aber am Sonntag, den 27. Oktober 2019, wenn wir die Uhr um eine Stunde eingestellt haben. Da die Ortszeit keine Informationen darüber enthält, ob es sich um +02: 00 oder +01: 00 handelt, geben beide beim Konvertieren der Zeit 02:00:00 beim ersten und beim zweiten Mal denselben Zeitstempel an (ab dem zweiten 02:00) : 00) bei Verwendung der MYSQL-
UNIX_TIMESTAMP(NOW(4))
Funktion. Beim Überprüfen der Zeitstempel in der Datenbank wurde Folgendes ausgeführt: +1 +1 +3601 +1 +1 ... +1 +1 -3599 +1 +1 usw.Local time | UTC Time | Timestamp | Timestamp using MYSQL's UNIX_TIMESTAMP(NOW(4)) ----------------------------------+---------------------------+--------------+----------------------------------------------------- 2019-10-27 01:59:59 CET (+02:00) | 2019-10-26 23:59:59 UTC | 1572134399 | 1572134399 2019-10-27 02:00:00 CET (+02:00) | 2019-10-27 00:00:00 UTC | 1572134400 | 1572138000 + 3601 seconds 2019-10-27 02:59:59 CET (+02:00) | 2019-10-27 00:59:59 UTC | 1572137999 | 1572141599 2019-10-27 02:00:00 CET (+01:00) | 2019-10-27 01:00:00 UTC | 1572138000 | 1572138000 - 3599 seconds 2019-10-27 02:59:59 CET (+01:00) | 2019-10-27 01:59:59 UTC | 1572141599 | 1572141599 2019-10-27 03:00:00 CET (+01:00) | 2019-10-27 02:00:00 UTC | 1572141600 | 1572141600 + 1 second
Das Weiterleiten der UNIX_TIMESTAMP () - Funktion von MySQL beim Konvertieren von Ortszeiten ist leider sehr unzuverlässig! Anstatt zu verwenden
SELECT UNIX_TIMESTAMP(NOW(4))
, verwenden wir jetzt den folgenden Code, der das Problem löst.SELECT ROUND(UNIX_TIMESTAMP() + (MICROSECOND(UTC_TIME(6))*0.000001), 4)
quelle
Ich hatte kürzlich das gleiche Problem und habe ein kleines Github-Projekt erstellt, das eine neue MySQL-Funktion enthält
UNIX_TIMESTAMP_MS()
, die den aktuellen Zeitstempel in Millisekunden zurückgibt.Sie können auch Folgendes tun:
SELECT UNIX_TIMESTAMP_MS(NOW(3))
oderSELECT UNIX_TIMESTAMP_MS(DateTimeField)
Das Projekt befindet sich hier: https://github.com/silviucpp/unix_timestamp_ms
Zum Kompilieren müssen Sie nur ausführen
make compile
im Projektstamm .Dann müssen Sie nur die gemeinsam genutzte Bibliothek in die kopieren
/usr/lib/mysql/plugin/
(oder einen beliebigen Plugin-Ordner auf Ihrem Computer) .Öffnen Sie danach einfach eine MySQL-Konsole und führen Sie Folgendes aus:
CREATE FUNCTION UNIX_TIMESTAMP_MS RETURNS INT SONAME 'unix_timestamp_ms.so';
Ich hoffe das wird helfen, Silviu
quelle
Gehen Sie für Millisekunden wie folgt vor:
select round(date_format(CURTIME(3), "%f")/1000)
Sie können Mikrosekunden wie folgt erhalten:
select date_format(CURTIME(6), "%f")
quelle