Come posso convertire bigint (UNIX timestamp) datetime SQL Server?

Come posso convertire UNIX timestamp (bigint) DateTime SQL Server?

  • si dovrebbe davvero esaminare Daniel Po ‘ di post per un possibile cambiamento accettato di rispondere.
InformationsquelleAutor salman | 2010-05-25

 

13 Replies
  1. 51

    provare:

    CREATE FUNCTION dbo.fn_ConvertToDateTime (@Datetime BIGINT)
    RETURNS DATETIME
    AS
    BEGIN
        DECLARE @LocalTimeOffset BIGINT
               ,@AdjustedLocalDatetime BIGINT;
        SET @LocalTimeOffset = DATEDIFF(second,GETDATE(),GETUTCDATE())
        SET @AdjustedLocalDatetime = @Datetime - @LocalTimeOffset
        RETURN (SELECT DATEADD(second,@AdjustedLocalDatetime, CAST('1970-01-01 00:00:00' AS datetime)))
    END;
    GO
    • +1 Per l’UTC->locale di conversione. Nota che l’estate/inverno sarà ancora fuori se si tenta di tradurre il 10 giugno durante il mese di febbraio.
    • -1 per l’UTC->locale di conversione. Non gestisce correttamente l’ora legale. Per me, questo è fuorviante.
    • +1 per la soluzione creativa! Funziona alla grande. Cordiali saluti, c’è un errore di sintassi SQL. Il punto e virgola alla fine della prima “DICHIARARE” la linea deve essere rimosso in quanto una virgola segue.
    • Non funziona per me. Sto cercando con 1517270400000 e sempre questo errore: errore di overflow Aritmetico conversione di espressione per il tipo di dati int.
    • Ho riscontrato un problema quando il @Datetime era fuori int intervallo ‘errore di overflow Aritmetico’ così I post di una versione migliorata di questo grande soluzione: stackoverflow.com/a/53177954/687490
    • Inoltre, è stato sempre un overflow, normalmente significa che i millisecondi sono coinvolti, risolto semplicemente come: select dbo.fn_ConvertToDateTime( src_column/1000 ) da src_table;
    • il tempo di 1517270400000 epoca è milli-secondi. Dividi per 1000 e dovrebbe funzionare.

  2. 252

    Questo ha funzionato per me:

    Select
        dateadd(S, [unixtime], '1970-01-01')
    From [Table]

    In questo caso, ci si chiede perché 1970-01-01 ,Questo è chiamato Epoch time.Qui di seguito è una citazione da wikipedia

    il numero di secondi trascorsi dall’00:00:00 UTC (Coordinated Universal Time), giovedì 1 gennaio 1970[1][1] non contando i secondi bisestili

    • Questo dovrebbe essere contrassegnati come corretto. Vorrei poter dare un voto positivo a questa risposta di nuovo ogni volta che atterro qui 🙂
    • Ho davvero d’accordo con te. Quello che una soluzione elegante. Ho guardato tutto per una formula e, infine, optato per uno solo di andare alla ricerca di nuovo quando ho iniziato a correre in errori, una settimana più tardi. Per fortuna ho trovato questo sul secondo giro.
    • Ho un errore function dateadd does not exist
    • Ho utilizzato questa soluzione. Questa data formattata era concatenad con altri dati, così ho avuto un varchar… Facile! C’è bisogno di preoccuparsi per il formato di tali registri dell’applicazione. Tuttavia, alcuni selvatici fuso orario problemi apparso! Le mie date sono state utilizzando il fuso orario UTC invece del tempo di un cliente zona 🙁
    • Non so se hai già risolto il tuo problema, ma guardare l’involucro! Magari le regole di confronto del database è impostato su qualcosa di simile a ‘SQL_Latin1_General_CP1_CS_AS’, CS è la parola chiave qui. Esso sta per “CaseSensitiv” perciò il codice deve corrispondere l’involucro! Un altro punto potrebbe essere che il vostro Sistema è MySql, che il nome è date_add(). Saluti 😉
    • Qualcuno ha una versione di questo che non soffre il 2038 problema? (DateAdd converte in un int, quindi questa soluzione è vulnerabile). en.wikipedia.org/wiki/Year_2038_problem
    • Questa soluzione sarà interessato dal anno 2038 problema, in quanto la funzione dateadd richiede un tipo int. La documentazione dice che “L’argomento numero non può superare la gamma di int”. docs.microsoft.com/en-us/sql/t-sql/functions/… en.wikipedia.org/wiki/Year_2038_problem
    • Di notare che la data/ora restituito da questa funzione sarebbe UTC, non locale data/ora. Conversione in locale è un vero e proprio dolore in fondo.
    • questo causa un overflow Aritmetico a causa di timestamp che non è più “in forma” in un int
    • Bella soluzione ma, se il database di account ha accesso limitato (cioè a dire non è possibile eseguire lato server funziona) questo non funziona. ad esempio, mysql: ERROR 1370 (42000): execute command denied to user 'mydbuser'@'%' for routine 'mydbname.dateadd'

  3. 20

    Come questo

    aggiungere Unix (epoca) datetime per la data di base in pochi secondi

    questo sarà ottenere, per ora (2010-05-25 07:56:23.000)

     SELECT dateadd(s,1274756183,'19700101 05:00:00:000')

    Se si vuole andare indietro, dare un’occhiata a questo http://wiki.lessthandot.com/index.php/Epoch_Date

    • perché 05:00:00 invece di 00:00:00?
    • 5 ore di differenza di fuso orario. 5:00:00 significa che è GMT-5 ore
    • Funziona come un fascino. Se è necessario regolare per il fuso orario, quindi certamente farlo, ma ritengo questo molto efficiente
  4. 16

    Se chi “errore di overflow Aritmetico conversione di espressione per il tipo di dati int” a causa di unix timestamp è in bigint (invece di int), è possibile utilizzare questo:

    SELECT DATEADD(S, CONVERT(int,LEFT(1462924862735870900, 10)), '1970-01-01')
    FROM TABLE

    Sostituire il hardcoded timestamp per la vostra colonna con unix timestamp

    Fonte: MSSQL bigint Timestamp Unix di tipo Datetime millisecondi

  5. 7

    Questo farò:

    declare @UNIX_TIME int
    select @UNIX_TIME = 1111111111
    -- Using dateadd to add seconds to 1970-01-01
    select [Datetime from UNIX Time] = dateadd(!precision!,@UNIX_TIME,'1970-01-01')

    Invece di !la precisione! uso: ss,ms o mcs in base alla precisione di timestamp.
    Bigint è in grado di tenere microsecondo di precisione.

  6. 1

    Questa è la costruzione di disattivare il lavoro di Daniel Poco ha fatto per questa domanda, ma tenendo conto dell’ora legale (funziona per le date 01-01 il 1902 e il maggiore a causa int limite di funzione dateadd):

    Abbiamo prima bisogno di creare una tabella per memorizzare gli intervalli di date per l’ora legale (fonte: Storia di un periodo negli Stati Uniti):

    CREATE TABLE [dbo].[CFG_DAY_LIGHT_SAVINGS_TIME](
      [BEGIN_DATE] [datetime] NULL,
      [END_DATE] [datetime] NULL,
      [YEAR_DATE] [smallint] NULL
    ) ON [PRIMARY]
    
    GO
    
    INSERT INTO CFG_DAY_LIGHT_SAVINGS_TIME VALUES
    ('2001-04-01 02:00:00.000',   '2001-10-27 01:59:59.997',    2001),
    ('2002-04-07 02:00:00.000',   '2002-10-26 01:59:59.997',    2002),
    ('2003-04-06 02:00:00.000',   '2003-10-25 01:59:59.997',    2003),
    ('2004-04-04 02:00:00.000',   '2004-10-30 01:59:59.997',    2004),
    ('2005-04-03 02:00:00.000',   '2005-10-29 01:59:59.997',    2005),
    ('2006-04-02 02:00:00.000',   '2006-10-28 01:59:59.997',    2006),
    ('2007-03-11 02:00:00.000',   '2007-11-03 01:59:59.997',    2007),
    ('2008-03-09 02:00:00.000',   '2008-11-01 01:59:59.997',    2008),
    ('2009-03-08 02:00:00.000',   '2009-10-31 01:59:59.997',    2009),
    ('2010-03-14 02:00:00.000',   '2010-11-06 01:59:59.997',    2010),
    ('2011-03-13 02:00:00.000',   '2011-11-05 01:59:59.997',    2011),
    ('2012-03-11 02:00:00.000',   '2012-11-03 01:59:59.997',    2012),
    ('2013-03-10 02:00:00.000',   '2013-11-02 01:59:59.997',    2013),
    ('2014-03-09 02:00:00.000',   '2014-11-01 01:59:59.997',    2014),
    ('2015-03-08 02:00:00.000',   '2015-10-31 01:59:59.997',    2015),
    ('2016-03-13 02:00:00.000',   '2016-11-05 01:59:59.997',    2016),
    ('2017-03-12 02:00:00.000',   '2017-11-04 01:59:59.997',    2017),
    ('2018-03-11 02:00:00.000',   '2018-11-03 01:59:59.997',    2018),
    ('2019-03-10 02:00:00.000',   '2019-11-02 01:59:59.997',    2019),
    ('2020-03-08 02:00:00.000',   '2020-10-31 01:59:59.997',    2020),
    ('2021-03-14 02:00:00.000',   '2021-11-06 01:59:59.997',    2021),
    ('2022-03-13 02:00:00.000',   '2022-11-05 01:59:59.997',    2022),
    ('2023-03-12 02:00:00.000',   '2023-11-04 01:59:59.997',    2023),
    ('2024-03-10 02:00:00.000',   '2024-11-02 01:59:59.997',    2024),
    ('2025-03-09 02:00:00.000',   '2025-11-01 01:59:59.997',    2025),
    ('1967-04-30 02:00:00.000',   '1967-10-29 01:59:59.997',    1967),
    ('1968-04-28 02:00:00.000',   '1968-10-27 01:59:59.997',    1968),
    ('1969-04-27 02:00:00.000',   '1969-10-26 01:59:59.997',    1969),
    ('1970-04-26 02:00:00.000',   '1970-10-25 01:59:59.997',    1970),
    ('1971-04-25 02:00:00.000',   '1971-10-31 01:59:59.997',    1971),
    ('1972-04-30 02:00:00.000',   '1972-10-29 01:59:59.997',    1972),
    ('1973-04-29 02:00:00.000',   '1973-10-28 01:59:59.997',    1973),
    ('1974-01-06 02:00:00.000',   '1974-10-27 01:59:59.997',    1974),
    ('1975-02-23 02:00:00.000',   '1975-10-26 01:59:59.997',    1975),
    ('1976-04-25 02:00:00.000',   '1976-10-31 01:59:59.997',    1976),
    ('1977-04-24 02:00:00.000',   '1977-10-31 01:59:59.997',    1977),
    ('1978-04-30 02:00:00.000',   '1978-10-29 01:59:59.997',    1978),
    ('1979-04-29 02:00:00.000',   '1979-10-28 01:59:59.997',    1979),
    ('1980-04-27 02:00:00.000',   '1980-10-26 01:59:59.997',    1980),
    ('1981-04-26 02:00:00.000',   '1981-10-25 01:59:59.997',    1981),
    ('1982-04-25 02:00:00.000',   '1982-10-25 01:59:59.997',    1982),
    ('1983-04-24 02:00:00.000',   '1983-10-30 01:59:59.997',    1983),
    ('1984-04-29 02:00:00.000',   '1984-10-28 01:59:59.997',    1984),
    ('1985-04-28 02:00:00.000',   '1985-10-27 01:59:59.997',    1985),
    ('1986-04-27 02:00:00.000',   '1986-10-26 01:59:59.997',    1986),
    ('1987-04-05 02:00:00.000',   '1987-10-25 01:59:59.997',    1987),
    ('1988-04-03 02:00:00.000',   '1988-10-30 01:59:59.997',    1988),
    ('1989-04-02 02:00:00.000',   '1989-10-29 01:59:59.997',    1989),
    ('1990-04-01 02:00:00.000',   '1990-10-28 01:59:59.997',    1990),
    ('1991-04-07 02:00:00.000',   '1991-10-27 01:59:59.997',    1991),
    ('1992-04-05 02:00:00.000',   '1992-10-25 01:59:59.997',    1992),
    ('1993-04-04 02:00:00.000',   '1993-10-31 01:59:59.997',    1993),
    ('1994-04-03 02:00:00.000',   '1994-10-30 01:59:59.997',    1994),
    ('1995-04-02 02:00:00.000',   '1995-10-29 01:59:59.997',    1995),
    ('1996-04-07 02:00:00.000',   '1996-10-27 01:59:59.997',    1996),
    ('1997-04-06 02:00:00.000',   '1997-10-26 01:59:59.997',    1997),
    ('1998-04-05 02:00:00.000',   '1998-10-25 01:59:59.997',    1998),
    ('1999-04-04 02:00:00.000',   '1999-10-31 01:59:59.997',    1999),
    ('2000-04-02 02:00:00.000',   '2000-10-29 01:59:59.997',    2000)
    GO

    Ora dobbiamo creare una funzione per ogni fuso orario Americano. Questo è supponendo che unix è il tempo in millisecondi. Se si è in pochi secondi, rimuovere la /1000 dal codice:

    Pacifico

    create function [dbo].[UnixTimeToPacific] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @pacificdatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @pacificdatetime =  dateadd(hour,case when @interimdatetime between begin_date and end_date then -7 else -8 end  ,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
         if @pacificdatetime is null 
           select @pacificdatetime= dateadd(hour, -7, @interimdatetime)
    return @pacificdatetime    
    end

    Orientale

    create function [dbo].[UnixTimeToEastern] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @easterndatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @easterndatetime =  dateadd(hour,case when @interimdatetime between begin_date and end_date then -4 else -5 end  ,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
         if @easterndatetime is null 
           select @easterndatetime= dateadd(hour, -4, @interimdatetime)
    return @easterndatetime    
    end

    Centrale

    create function [dbo].[UnixTimeToCentral] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @centraldatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @centraldatetime =  dateadd(hour,case when @interimdatetime between begin_date and end_date then -5 else -6 end  ,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
         if @centraldatetime is null 
           select @centraldatetime= dateadd(hour, -5, @interimdatetime)
    return @centraldatetime    
    end

    Montagna

    create function [dbo].[UnixTimeToMountain] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @mountaindatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @mountaindatetime =  dateadd(hour,case when @interimdatetime between begin_date and end_date then -6 else -7 end  ,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
         if @mountaindatetime is null 
           select @mountaindatetime= dateadd(hour, -6, @interimdatetime)
    return @mountaindatetime    
    end

    Hawaii

    create function [dbo].[UnixTimeToHawaii] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @hawaiidatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @hawaiidatetime =  dateadd(hour,-10,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
    
    return @hawaiidatetime    
    end

    Arizona

    create function [dbo].[UnixTimeToArizona] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @arizonadatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @arizonadatetime =  dateadd(hour,-7,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
    
    return @arizonadatetime    
    end

    Alaska

    create function [dbo].[UnixTimeToAlaska] 
     (@unixtime bigint)
       returns datetime
       as
       begin
         declare @alaskadatetime datetime
         declare @interimdatetime datetime = dateadd(s, @unixtime/1000, '1970-01-01')
         select  @alaskadatetime =  dateadd(hour,case when @interimdatetime between begin_date and end_date then -8 else -9 end  ,@interimdatetime)
         from cfg_day_light_savings_time  where  year_date = datepart(year,@interimdatetime)
         if @alaskadatetime is null 
           select @alaskadatetime= dateadd(hour, -8, @interimdatetime)
    return @alaskadatetime    
    end
  7. 0

    Meglio? Questa funzione converte unixtime in millisecondi per datetime. Si è perso il millisecondi, ma ancora molto utile per il filtraggio.

    CREATE FUNCTION [dbo].[UnixTimestampToGMTDatetime] 
    (@UnixTimestamp bigint)
    RETURNS datetime
    AS
    BEGIN
           DECLARE @GMTDatetime datetime
           select @GMTDatetime = 
           CASE
           WHEN dateadd(ss, @UnixTimestamp/1000, '1970-01-01') 
           BETWEEN 
               Convert(DATETIME, Convert(VARCHAR(4), Year(dateadd(ss, @UnixTimestamp/1000, '1970-01-01') )) + '-03-' + Convert(VARCHAR(2), (31 - (5 * Year(dateadd(ss, @UnixTimestamp/1000, '1970-01-01') )/4 + 4) % 7)) + ' 01:00:00', 20)
           AND
               Convert(DATETIME, Convert(VARCHAR(4), Year(dateadd(ss, @UnixTimestamp/1000, '1970-01-01') )) + '-10-' + Convert(VARCHAR(2), (31 - (5 * Year(dateadd(ss, @UnixTimestamp/1000, '1970-01-01') )/4 + 1) % 7)) + ' 02:00:00', 20)
           THEN Dateadd(hh, 1, dateadd(ss, @UnixTimestamp/1000, '1970-01-01'))
           ELSE Dateadd(hh, 0, dateadd(ss, @UnixTimestamp/1000, '1970-01-01'))
           END
    RETURN @GMTDatetime    
    END
  8. 0

    Aggiunta di n secondi per 1970-01-01 vi darà un data UTC perché n, il timestamp Unix, è il numero di secondi trascorsi dall’00:00:00 UTC (Coordinated Universal Time), giovedì 1 gennaio 1970.

    In SQL Server 2016, è possibile convertire un fuso orario all’altro utilizzando AL fuso ORARIO. Hai solo bisogno di sapere il nome del fuso orario nel formato standard di Windows:

    SELECT *
    FROM (VALUES (1514808000), (1527854400)) AS Tests(UnixTimestamp)
    CROSS APPLY (SELECT DATEADD(SECOND, UnixTimestamp, '1970-01-01') AT TIME ZONE 'UTC') AS CA1(UTCDate)
    CROSS APPLY (SELECT UTCDate AT TIME ZONE 'Pacific Standard Time') AS CA2(LocalDate)
    | UnixTimestamp | UTCDate                    | LocalDate                  |
    |--------------- | ---------------------------- | ----------------------------|
    | 1514808000    | 2018-01-01 12:00:00 +00:00 | 2018-01-01 04:00:00 -08:00 |
    | 1527854400    | 2018-06-01 12:00:00 +00:00 | 2018-06-01 05:00:00 -07:00 |

    O semplicemente:

    SELECT *, DATEADD(SECOND, UnixTimestamp, '1970-01-01') AT TIME ZONE 'UTC' AT TIME ZONE 'Pacific Standard Time'
    FROM (VALUES (1514808000), (1527854400)) AS Tests(UnixTimestamp)
    | UnixTimestamp | LocalDate                  |
    |--------------- | ----------------------------|
    | 1514808000    | 2018-01-01 04:00:00 -08:00 |
    | 1527854400    | 2018-06-01 05:00:00 -07:00 |

    Note:

    • Si può tagliare fuori le informazioni di fuso orario da casting DATETIMEOFFSET per DATETIME.
    • La conversione dell’ora legale in considerazione. Pacifico è stato UTC-08:00 su gennaio 2018 e UTC-07:00 su Giugno 2018.
  9. 0
    //BIGINT UNIX TIMESTAMP CONVERSION upto Millisecond Accuracy
    CREATE FUNCTION [dbo].[ConvertUnixTimestamp] (@Datetime [BIGINT]) RETURNS DATETIME
    AS
    BEGIN
    
        RETURN DATEADD(MILLISECOND, cast(@Datetime as bigint) % 1000, 
        DATEADD(SECOND, (cast(@Datetime as bigint) / 1000)%60, 
        DATEADD(MINUTE, ((cast(@Datetime as bigint) / 1000)/60)%60, 
        DATEADD(HOUR, ((cast(@Datetime as bigint) / 1000)/60)/60, '19700101'))))
    END
  10. 0

    Ho dovuto affrontare questo problema, troppo. Purtroppo, nessuna delle risposte (qui e in altre decine di pagine), è stata soddisfacente, per me, ancora non riesco a raggiungere le date oltre l’anno 2038 dovuto a 32 bit intero cast, da qualche parte.

    Una soluzione che ha funzionato per me, alla fine, era quello di utilizzare float variabili, così da poter avere almeno un max data di 2262-04-11T23:47:16.854775849. Ancora, questo non copre l’intero datetime di dominio, ma è sufficiente per le mie esigenze, e può aiutare gli altri a incontrare lo stesso problema.

    -- date variables
    declare @ts bigint; -- 64 bit time stamp, 100ns precision
    declare @d datetime2(7) = GETUTCDATE(); -- 'now'
    -- select @d = '2262-04-11T23:47:16.854775849'; -- this would be the max date
    
    -- constants:
    declare @epoch datetime2(7) = cast('1970-01-01T00:00:00' as datetime2(7));
    declare @epochdiff int = 25567; -- = days between 1900-01-01 and 1970-01-01
    declare @ticksofday bigint = 864000000000; -- = (24*60*60*1000*1000*10)
    
    -- helper variables:
    declare @datepart float;
    declare @timepart float;
    declare @restored datetime2(7);
    
    -- algorithm:
    select @ts = DATEDIFF_BIG(NANOSECOND, @epoch, @d) / 100; -- 'now' in ticks according to unix epoch
    select @timepart = (@ts % @ticksofday) / @ticksofday; -- extract time part and scale it to fractional part (i. e. 1 hour is 1/24th of a day)
    select @datepart = (@ts - @timepart) / @ticksofday; -- extract date part and scale it to fractional part
    select @restored = cast(@epochdiff + @datepart + @timepart as datetime); -- rebuild parts to a datetime value
    
    -- query original datetime, intermediate timestamp and restored datetime for comparison
    select
      @d original,
      @ts unix64,
      @restored restored
    ;
    
    -- example result for max date:
    -- +-----------------------------+-------------------+-----------------------------+
    -- | original                    | unix64            | restored                    |
    -- +-----------------------------+-------------------+-----------------------------+
    -- | 2262-04-11 23:47:16.8547758 | 92233720368547758 | 2262-04-11 23:47:16.8533333 |
    -- +-----------------------------+-------------------+-----------------------------+

    Ci sono alcuni punti da considerare:

    • 100ns di precisione è l’obbligo, nel mio caso, tuttavia questa sembra essere la risoluzione standard per la versione a 64 bit di unix timestamp. Se si utilizza qualsiasi altra risoluzione, è necessario regolare @ticksofday e la prima riga dell’algoritmo di conseguenza.
    • Sto utilizzando altri sistemi che hanno i loro problemi, con i fusi orari, ecc. e ho trovato la soluzione migliore per me sarebbe sempre utilizzando UTC. Per le vostre esigenze, questo può essere diverso.
    • 1900-01-01 è l’origine data per datetime2, proprio come è l’epoca 1970-01-01 per unix timestamp.
    • floats mi ha aiutato a risolvere i anno-2038-problema e integer overflow, e tale, ma di tenere presente che i numeri in virgola mobile non sono molto performante e può rallentare il processo di elaborazione di una grande quantità di timestamp. Inoltre, i galleggianti possono portare alla perdita di precisione a causa di errori di arrotondamento, come si può vedere dal confronto dei risultati dell’esempio per l’max data di cui sopra (qui, l’errore è di circa 1.4425 ms).
    • Nell’ultima riga dell’algoritmo c’è un cast di datetime. Purtroppo, non non c’è nessun cast esplicito da valori numerici datetime2 consentito, ma si è permesso di gettare numerici per datetime esplicitamente e questo, a sua volta, è il cast implicito per datetime2. Questo può essere corretto, per ora, ma potrebbe cambiare nelle future versioni di SQL Server: O ci sarà un dateadd_big() funzione o il cast esplicito a datetime2 sarà permesso o il cast esplicito a datetime sarà consentita, in modo da questo può rompere o ci può essere un modo più semplice di qualche giorno.
  11. 0

    Se il tempo è espresso in millisecondi e una necessità di preservare la loro:

    DECLARE @value VARCHAR(32) = '1561487667713';
    
        SELECT DATEADD(MILLISECOND, CAST(RIGHT(@value, 3) AS INT) - DATEDIFF(MILLISECOND,GETDATE(),GETUTCDATE()), DATEADD(SECOND, CAST(LEFT(@value, 10) AS INT), '1970-01-01T00:00:00'))
  12. 0

    Soluzione può essere la seguente:

    DECLARE @UnixTimeStamp bigint = 1564646400000 /*2019-08-01 11:00 AM*/
    
    DECLARE @LocalTimeOffset bigint = DATEDIFF(MILLISECOND, GETDATE(), GETUTCDATE());
    DECLARE @AdjustedTimeStamp bigint = @UnixTimeStamp - @LocalTimeOffset;
    SELECT [DateTime] = DATEADD(SECOND, @AdjustedTimeStamp % 1000, DATEADD(SECOND, @AdjustedTimeStamp / 1000, '19700101'));

Lascia un commento