CURRENT_TIMESTAMP en millisecondes

Existe-t-il un moyen d’obtenir des millisecondes à partir d’un horodatage dans MySql ou PostgreSql (ou d’autres simplement par curiosité)?

 SELECT CURRENT_TIMESTAMP --> 2012-03-08 20:12:06.032572 

Y a-t-il quelque chose comme ça:

 SELECT CURRENT_MILLISEC --> 1331255526000 

ou la seule alternative est d’utiliser le DATEDIFF de l’ era ?

Pour obtenir l’horodatage Unix en secondes dans MySQL:

 select UNIX_TIMESTAMP(); 

Détails: http://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html#function_unix-timestamp

Non testé PostgreSQL, mais selon ce site, il devrait fonctionner: http://www.raditha.com/postgres/timestamp.php

 select round( date_part( 'epoch', now() ) ); 

Pour MySQL (5.6+), vous pouvez le faire:

 SELECT ROUND(UNIX_TIMESTAMP(CURTIME(4)) * 1000) 

Qui retournera (par exemple):

 1420998416685 --milliseconds 

En mysql, il est possible d’utiliser la fonction uuid pour extraire des millisecondes.

 select conv( concat( subssortingng(uid,16,3), subssortingng(uid,10,4), subssortingng(uid,1,8)) ,16,10) div 10000 - (141427 * 24 * 60 * 60 * 1000) as current_mills from (select uuid() uid) as alias; 

Résultat:

 +---------------+ | current_mills | +---------------+ | 1410954031133 | +---------------+ 

Il fonctionne également dans les anciennes versions de mysql!

Merci à cette page: http://rpbouman.blogspot.com.es/2014/06/mysql-extracting-timstamp-and-mac.html

La manière correcte d’extraire des millisecondes d’une valeur d’horodatage sur PostgreSQL en fonction de la documentation actuelle est la suivante:

 SELECT date_part('milliseconds', current_timestamp); --OR SELECT EXTRACT(MILLISECONDS FROM current_timestamp); 

avec des retours: Le champ des secondes, y compris les parties fractionnaires, multiplié par 1000. Notez que cela inclut les secondes complètes.

Dans Mysql 5.7+, vous pouvez exécuter

 select current_timestamp(6) 

pour plus de détails

https://dev.mysql.com/doc/refman/5.7/fr/fractional-seconds.html

Utilisation:

 Select curtime(4); 

Cela vous donnera des millisecondes.

Dans PostgreSQL, vous pouvez utiliser:

 SELECT extract(epoch from now()); 

sur MySQL:

 SELECT unix_timestamp(now()); 

Aucune de ces réponses ne résout vraiment le problème dans postgreSQL , à savoir:

obtenir l’ horodatage unix d’un champ de date en millisecondes

J’ai eu le même problème et testé les différentes réponses précédentes sans résultat satisfaisant.

Enfin, j’ai trouvé un moyen très simple, probablement le plus simple:

 SELECT (EXTRACT (EPOCH FROM ::timestamp)::float*1000 as unix_tms FROM 

à savoir:

  • Nous extrayons le EPGCH de pgSQL, c’est-à-dire un timestamp unix en secondes flottantes de notre colonne convertie en timestamp (dans certaines requêtes complexes, pgSQL peut générer une erreur si ce cast n’est pas explicite).
  • alors nous le jetterons dans float et le multiplions par 1000 pour obtenir la valeur en millisecondes

Voici une expression qui fonctionne pour MariaDB et MySQL> = 5.6:

 SELECT (UNIX_TIMESTAMP(NOW()) * 1000000 + MICROSECOND(NOW(6))) AS unix_now_in_microseconds; 

Cela repose sur le fait que NOW () retourne toujours la même heure tout au long d’une requête ; il est possible qu’un UNIX_TIMESTAMP() soit aussi efficace, je ne suis pas sûr de la documentation . Il nécessite également MySQL> = 5.6 pour le nouvel argument de précision pour la fonction NOW() (MariaDB fonctionne également).

La manière la plus simple de trouver l’heure actuelle en millisecondes dans MySql:

 SELECT (UNIX_TIMESTAMP(NOW(3)) * 1000) 

Depuis MySql 5.6.

Le principal malentendu dans MySQL avec les horodatages est que MySQL, par défaut, retourne et stocke les horodatages sans partie fractionnaire .

 SELECT current_timestamp() => 2018-01-18 12:05:34 

qui peut être converti en secondes timestamp comme

 SELECT UNIX_TIMESTAMP(current_timestamp()) => 1516272429 

Pour append une partie fractionnaire:

 SELECT current_timestamp(3) => 2018-01-18 12:05:58.983 

qui peut être converti en horodatage en microsecondes comme

 SELECT CAST( 1000*UNIX_TIMESTAMP(current_timestamp(3)) AS UNSIGNED INTEGER) ts => 1516272274786 

Il y a peu d’astuces avec le stockage dans les tableaux. Si votre table a été créée comme

  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; 

que MySQL ne stockera PAS la partie fractionnaire:

  id, not_fractional_timestamp 1, 2018-01-18 11:35:12 

Si vous souhaitez append une partie fractionnaire à votre table, vous devez créer votre table d’une autre manière:

  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; 

cela conduit à un résultat requirejs:

  id, some_data, fractional_timestamp 1, 8, 2018-01-18 11:45:40.811 

La fonction current_timestamp () est autorisée à recevoir une valeur allant jusqu’à 6, mais j’ai découvert (au moins dans la version de MySQL 5.7.11 installée) que la précision de la fraction 6 conduit à la même valeur constante de 3 chiffres à la fin, dans mon cas 688

  id, some_data, fractional_timestamp 1, 2, 2018-01-18 12:01:54.167688 2, 4, 2018-01-18 12:01:58.893688 

Cela signifie que la vraie précision utilisable dans MySQL est 3.

J’ai ressenti le besoin de continuer à affiner, donc en MySQL:

Horodatage actuel en millisecondes:

 floor(unix_timestamp(current_timestamp(3)) * 1000) 

Horodatage en millisecondes à partir de datetime donné (3):

 floor(unix_timestamp("2015-04-27 15:14:55.692") * 1000) 

Convertir l’horodatage en millisecondes en datetime (3):

 from_unixtime(1430146422456 / 1000) 

Convertissez datetime (3) en horodatage en millisecondes:

 floor(unix_timestamp("2015-04-27 14:53:42.456") * 1000) 

Dans MariaDB, vous pouvez utiliser

 SELECT NOW(4); 

Pour obtenir des milisecs. Voir ici aussi.

Dans PostgreSQL, nous utilisons cette approche:

 SELECT round(EXTRACT (EPOCH FROM now())::float*1000) 

J’ai rencontré le même problème récemment et j’ai créé un petit projet github qui contient une nouvelle fonction mysql UNIX_TIMESTAMP_MS() qui renvoie l’horodatage actuel en millisecondes.

Vous pouvez également faire ce qui suit:

SELECT UNIX_TIMESTAMP_MS(NOW(3)) ou SELECT UNIX_TIMESTAMP_MS(DateTimeField)

Le projet est situé ici: https://github.com/silviucpp/unix_timestamp_ms

Pour comstackr, vous devez exécuter simplement make comstack dans la racine du projet.

Ensuite, vous ne devez copier que la bibliothèque partagée dans /usr/lib/mysql/plugin/ (ou quel que soit le dossier du plug-in sur votre machine).

Après cela, ouvrez simplement une console mysql et lancez:

CREATE FUNCTION UNIX_TIMESTAMP_MS RETURNS INT SONAME 'unix_timestamp_ms.so';

J’espère que cela aidera, Silviu

Dans MySQL:

  SELECT UNIX_TIMESTAMP() * 1000;