UNIX_TIMESTAMP en SQL Server

Question

Necesito crear una función en SQL Server 2008 que imitará UNIX_TIMESTAMP() de mysql.

¡Gracias de antemano!

Answer 1

Prueba este mensaje: http://skinn3r.wordpress.com/2009/01/26/t-sql-datetime-to-unix-timestamp/

CREATE FUNCTION UNIX_TIMESTAMP (
@ctimestamp datetime 
) 
RETURNS integer 
AS 
BEGIN 
    /* Function body */ 
    declare @return integer 

    SELECT @return = DATEDIFF(SECOND,{d '1970-01-01'}, @ctimestamp) 

    return @return 
END 

o este post:

http://mysql.databases.aspfaq.com/how-do-i-convert-a-sql-server-datetime-value-to-a-unix-timestamp.html

código es el siguiente: el uso

CREATE FUNCTION dbo.DTtoUnixTS 
( 
    @dt DATETIME 
) 
RETURNS BIGINT 
AS 
BEGIN 
    DECLARE @diff BIGINT 
    IF @dt >= '20380119' 
    BEGIN 
     SET @diff = CONVERT(BIGINT, DATEDIFF(S, '19700101', '20380119')) 
      + CONVERT(BIGINT, DATEDIFF(S, '20380119', @dt)) 
    END 
    ELSE 
     SET @diff = DATEDIFF(S, '19700101', @dt) 
    RETURN @diff 
END 

muestra:

SELECT dbo.DTtoUnixTS(GETDATE()) 
-- or 
SELECT UnixTimestamp = dbo.DTtoUnixTS(someColumn) 
    FROM someTable 

Answer 2

Necromancing.
El ODBC vías:

DECLARE @unix_timestamp varchar(20) 
-- SET @unix_timestamp = CAST({fn timestampdiff(SQL_TSI_SECOND,{d '1970-01-01'}, CURRENT_TIMESTAMP)} AS varchar(20)) 

IF CURRENT_TIMESTAMP >= '20380119' 
BEGIN 
    SET @unix_timestamp = CAST 
    (
     CAST 
     (
      {fn timestampdiff(SQL_TSI_SECOND,{d '1970-01-01'}, {d '2038-01-19'})} 
      AS bigint 
     ) 
     + 
     CAST 
     (
      {fn timestampdiff(SQL_TSI_SECOND,{d '2038-01-19'}, CURRENT_TIMESTAMP)} 
      AS bigint 
     ) 
    AS varchar(20) 
    ) 
END 
ELSE 
    SET @unix_timestamp = CAST({fn timestampdiff(SQL_TSI_SECOND,{d '1970-01-01'}, CURRENT_TIMESTAMP)} AS varchar(20)) 

PRINT @unix_timestamp 

Answer 3

que a menudo necesitan una marca de tiempo UNIX con una precisión de milisegundos. Lo siguiente le dará el tiempo unixtime actual como FLOAT; envuélvalo por las respuestas anteriores para obtener una función o convertir cadenas arbitrarias.

El tipo de datos DATETIME en SQL Server solo es bueno para 3 mseg, así que tengo diferentes ejemplos para SQL Server 2005 y 2008+. Lamentablemente no existe la función DATEDIFF2, por lo que se requieren varios trucos para evitar el desbordamiento de entero DATEDIFF incluso con 2008+. (No puedo creer que introdujeron un nuevo tipo de datos DATETIME2 sin arreglar esto.)

Para regular de edad DATETIME, sólo tiene que utilizar un yeso de mala calidad a flotar, que devuelve (coma flotante) número de días desde 1900.

Ahora sé que en este punto, usted está pensando ¿QUÉ ACERCA DE LEAP SECONDS?!?! Ni el tiempo de Windows ni el tiempo real realmente creen en segundos intercalares: un día es siempre de 1,00000 días para SQL Server y de 86400 segundos para unixtime. This wikipedia article explica cómo se comporta unixtime durante los segundos intercalares; Creo que Windows solo visualiza segundos increíbles como cualquier otro error de reloj. Entonces, si bien no existe una deriva sistemática entre los dos sistemas cuando ocurre un segundo intercalar, no se pondrán de acuerdo en el nivel de segundo nivel durante e inmediatamente después de un segundo intercalar.

-- the right way, for sql server 2008 and greater 
declare @unixepoch2 datetime2; 
declare @now2 Datetime2; 
declare @days int; 
declare @millisec int; 
declare @today datetime2; 
set @unixepoch2 = '1970-01-01 00:00:00.0000'; 
set @now2 = SYSUTCDATETIME(); 
set @days = DATEDIFF(DAY,@unixepoch2,@now2); 
set @today = DATEADD(DAY,@days,@unixepoch2); 
set @millisec = DATEDIFF(MILLISECOND,@today,@now2); 
select (CAST (@days as float) * 86400) + (CAST(@millisec as float)/1000) 
    as UnixTimeFloatSQL2008 

-- Note datetimes are only accurate to 3 msec, so this is less precise 
-- than above, but works on any edition of SQL Server. 
declare @sqlepoch datetime; 
declare @unixepoch datetime; 
declare @offset float; 
set @sqlepoch = '1900-01-01 00:00:00'; 
set @unixepoch = '1970-01-01 00:00:00'; 
set @offset = cast (@sqlepoch as float) - cast (@unixepoch as float); 
select (cast (GetUTCDate() as float) + @offset) * 86400 
    as UnixTimeFloatSQL2005; 

-- Future developers may hate you, but you can put the offset in 
-- as a const because it isn't going to change. 
declare @sql_to_unix_epoch_in_days float; 
set @sql_to_unix_epoch_in_days = 25567.0; 
select (cast (GetUTCDate() as float) - @sql_to_unix_epoch_in_days) * 86400.0 
    as UnixTimeFloatSQL2005MagicNumber; 

Los FLOAT realidad por defecto a 8 bytes se duplica en SQL Server, y por lo tanto superior a 32 bits INT para muchos casos de uso. (Por ejemplo, no se darán la vuelta en 2038).)

Answer 4

Si no está preocupado acerca de las fechas antes de 1970, o la precisión de milisegundos, acaba de hacer:

-- SQL Server 
SELECT DATEDIFF(s, '1970-01-01 00:00:00', DateField) 

Casi tan simple como función integrada de MySQL:

-- MySQL 
SELECT UNIX_TIMESTAMP(DateField); 

Otros idiomas (Oracle, PostgreSQL, etc): How To Get The Current Epoch Time (Unix Timestamp)

Answer 5

Cuando se llama a las funciones con valores escalares pueden utilizar follwing sintaxis

Guión

Función:

USO [Base de datos] GO

/****** Objeto:. UserDefinedFunction [dbo] [UNIX_TIMESTAMP] ******/ ANSI_NULLS EN GO

QUOTED_IDENTIFIER

SET EN GO

función Crear [dbo]. [UNIX_TIMESTAMP] ( @ctimestamp datetime ) RETURNS integer AS COMENZAR /* cuerpo de la función */ declare número entero @return

SELECT @return = DATEDIFF (SEGUNDO, {d '1970-01-01'}, @ctimestamp)

retorno @return FIN IR

llamada Función: SELECT dbo.UNIX_TIMESTAMP (GETDATE());