unix_timestamp timestampdiff data current_timestamp mysql sql postgresql datetime timestamp

data - timestampdiff mysql



CURRENT_TIMESTAMP en milisegundos (16)

Aquí hay una expresión que funciona para MariaDB y MySQL> = 5.6:

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

Esto se basa en el hecho de que NOW () siempre devuelve el mismo tiempo a lo largo de una consulta ; es posible que un UNIX_TIMESTAMP() simple UNIX_TIMESTAMP() también, no estoy seguro en función de la documentación . También requiere MySQL> = 5.6 para el nuevo argumento de precisión para la función NOW() (MariaDB también funciona).

¿Hay alguna manera de sacar milisegundos de una marca de tiempo en MySql o PostgreSql (u otros solo por curiosidad)?

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

Hay algo como esto:

SELECT CURRENT_MILLISEC --> 1331255526000

o la única alternativa es usar el DATEDIFF de la era ?


El principal malentendido en MySQL con timestamps es que MySQL devuelve por defecto y almacena marcas de tiempo sin una parte fraccionaria .

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

que se puede convertir a segundos timestamp como

SELECT UNIX_TIMESTAMP(current_timestamp()) => 1516272429

Para agregar una parte fraccional:

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

que se puede convertir a microsegundos timestamp como

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

Hay algunos trucos con el almacenamiento en tablas. Si tu tabla fue creada como

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 NO almacenará una parte fraccional dentro de ella:

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

Si desea agregar una parte fraccional a su tabla, debe crear su tabla de otra forma:

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;

eso lleva a un resultado requerido:

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

La función current_timestamp () tiene permitido recibir un valor de hasta 6, pero descubrí (al menos en mi versión instalada de MySQL 5.7.11) que la precisión de fracción 6 conduce al mismo valor constante de 3 dígitos en la cola, en mi caso 688

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

Eso significa que la precisión real utilizable en MySQL es 3.


En PostgreSQL utilizamos este enfoque:

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


En MariaDB puedes usar

SELECT NOW(4);

Para obtener milisecs. Vea here , también.


En MySQL:

SELECT UNIX_TIMESTAMP() * 1000;



En PostgreSQL puede usar:

SELECT extract(epoch from now());

en MySQL:

SELECT unix_timestamp(now());


En mysql, es posible usar la función uuid para extraer milisegundos.

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;

Resultado:

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

¡También funciona en versiones antiguas de MySQL!

Gracias a esta página: http://rpbouman.blogspot.com.es/2014/06/mysql-extracting-timstamp-and-mac.html


La forma correcta de extraer milisegundos de un valor de marca de tiempo en PostgreSQL según la documentación actual es:

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

con devoluciones: el campo de segundos, que incluye partes fraccionales, multiplicado por 1000. Tenga en cuenta que esto incluye segundos completos.


La forma más fácil que encontré para recibir la hora actual en milisegundos en MySql:

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

Desde MySql 5.6.


Me enfrenté al mismo problema recientemente y creé un pequeño proyecto github que contiene una nueva función mysql UNIX_TIMESTAMP_MS() que devuelve la marca de tiempo actual en milisegundos.

También puedes hacer lo siguiente:

SELECT UNIX_TIMESTAMP_MS(NOW(3)) o SELECT UNIX_TIMESTAMP_MS(DateTimeField)

El proyecto se encuentra aquí: https://github.com/silviucpp/unix_timestamp_ms

Para compilar, solo necesita ejecutar make compile en la raíz del proyecto.

Luego, solo debe copiar la biblioteca compartida en /usr/lib/mysql/plugin/ (o lo que sea que la carpeta del complemento esté en su máquina).

Después de esto, solo abra una consola mysql y ejecute:

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

Espero que esto ayude, Silviu


Ninguna de estas respuestas realmente resuelve el problema en postgreSQL , es decir:

obtener la marca de tiempo de unix de un campo de fecha en milisegundos

Tuve el mismo problema y probé las diferentes respuestas anteriores sin obtener resultados satisfactorios.

Finalmente, encontré una manera realmente simple, probablemente la más simple:

SELECT (EXTRACT (EPOCH FROM <date_column>::timestamp)::float*1000 as unix_tms FROM <table>

a saber:

  • Extraemos el pgSQL EPOCH , es decir, la marca de tiempo de unix en segundos flotantes de nuestra columna generada en la prudencia de la marca de tiempo (en algunas consultas complejas, pgSQL podría detectar un error si este colado no es explícito. Consulte)
  • luego lo lanzamos en flotación y lo multiplicamos por 1000 para obtener el valor en milisegundos

Para MySQL (5.6+) puedes hacer esto:

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

Cuál regresará (por ejemplo):

1420998416685 --milliseconds



Sentí la necesidad de seguir refinando, entonces en MySQL:

Marca de tiempo actual en milisegundos:

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

Marca de tiempo en milisegundos a partir de datetime (3):

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

Convertir marca de tiempo en milisegundos a fecha y hora (3):

from_unixtime(1430146422456 / 1000)

Convierta datetime (3) en timestamp en milisegundos:

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


Utilizar:

Select curtime(4);

Esto te dará milisegundos.