programing

를 저장하기 위한 올바른 SQL 유형은 무엇입니까?값이 24:00:00보다 큰 Net Timespan?

bestprogram 2023. 4. 7. 22:03

를 저장하기 위한 올바른 SQL 유형은 무엇입니까?값이 24:00:00보다 큰 Net Timespan?

저장하려고 합니다. ★★TimeSpanSQL Server 2008 R2 입니다.

Code First로 것 같습니다.Time(7)SQL sql sql sql sql sql 。

, <고객명>님TimeSpan긴 할 수 있습니다.Net에서는 24시간보다 긴 기간을 처리할 수 있습니다.

저장을 처리하는 가장 좋은 방법은 무엇입니까? ★★TimeSpanSQL Server?

에 BIGINT그리고 진드기 수를 저장합니다(예:시간 범위틱스 속성).

이렇게 하면 TimeSpan 개체를 가져올 때 TimeSpan 개체를 가져올 수 있습니다.FromTicks(값)는 쉬울 것 같습니다.

조언해 주셔서 고마워요.SQL 서버에는 동등한 것이 없기 때문입니다.TimeSpan을 틱으로 변환하여 DB에 저장하는 두 번째 필드를 만들었습니다.그 후 TimeSpan을 저장하지 않도록 했습니다.

public Int64 ValidityPeriodTicks { get; set; }

[NotMapped]
public TimeSpan ValidityPeriod
{
    get { return TimeSpan.FromTicks(ValidityPeriodTicks); }
    set { ValidityPeriodTicks = value.Ticks; }
}

24시간 이상 저장할 필요가 없다면 시간만 저장할 수 있습니다. SQL Server 2008 이후 매핑은 다음과 같습니다.

time (SQL Server) <-> TimeSpan(.NET)

24시간 이내만 저장하면 변환이 필요 없습니다.

출처 : http://msdn.microsoft.com/en-us/library/cc716729(v=vs.110).aspx

단, 24시간 이상 저장할 경우 틱으로 저장하고 데이터를 가져온 다음 TimeSpan으로 변환해야 합니다.예를들면

int timeData = yourContext.yourTable.FirstOrDefault();
TimeSpan ts = TimeSpan.FromMilliseconds(timeData);

직접적인 등가물은 없다.예를 들어, 초수나 필요한 정확도에 맞는 수치로 저장하기만 하면 됩니다.

데이터베이스에 시간 범위를 표시하는 방법은 여러 가지가 있습니다.

시간을

이 데이터 타입은 SQL Server 2008부터 지원되고 있으며, 이 데이터 타입을 저장하기 위해 권장되는 방법입니다.TimeSpan 없습니다. 매핑은 필요 없습니다.드 sql SQL 。 

public TimeSpan ValidityPeriod { get; set; }

그러나 원래 질문에서 설명한 바와 같이 이 데이터 유형은 24시간으로 제한됩니다.

datetime offset

datetimeoffset " "에 매핑됩니다.System.DateTimeOffset이 말은 '어울리다'와 '의 차이를 때 datetime/datetime2 UTC에도 할 수 .TimeSpan

그러나 데이터 유형은 매우 구체적인 의미를 나타내므로 다른 옵션도 고려해야 합니다.

datetime / datetime 2

가지 은 '먹다'를 입니다.datetime ★★★★★★★★★★★★★★★★★」datetime2이것은 보기, 저장 프로시저 또는 보고서와 같이 데이터베이스의 값을 직접 처리해야 하는 시나리오에서 가장 적합합니다.은 값을 입니다.DateTime(1900,01,01,00,00,00)비즈니스 로직의 타임 스팬을 되돌리기 위해서입니다. 

public DateTime ValidityPeriod { get; set; }

[NotMapped]
public TimeSpan ValidityPeriodTimeSpan
{
    get { return ValidityPeriod - DateTime(1900,01,01,00,00,00); }
    set { ValidityPeriod = DateTime(1900,01,01,00,00,00) + value; }
}

비긴트

다른 하여 "Da" "TimeSpan" 을 하는 입니다.bigint 쿼리에서 .그러나 이 방법에는 SQL 쿼리에서 사용하기 번거롭다는 단점이 있습니다. 

public long ValidityPeriod { get; set; }

[NotMapped]
public TimeSpan ValidityPeriodTimeSpan
{
    get { return TimeSpan.FromTicks(ValidityPeriod); }
    set { ValidityPeriod = value.Ticks; }
}

varchar(N)

이는 사람이 값을 읽을 수 있어야 하는 경우에 가장 적합합니다.하여 이 도 있습니다.CONVERT(datetime, ValidityPeriod). 합니다.필요한 정밀도에 따라 8~25자의 문자가 필요합니다. 

public string ValidityPeriod { get; set; }

[NotMapped]
public TimeSpan ValidityPeriodTimeSpan
{
    get { return TimeSpan.Parse(ValidityPeriod); }
    set { ValidityPeriod = value.ToString("HH:mm:ss"); }
}

보너스: 기간 및 기간

문자열을 사용하여 특히 Noda Time 데이터 유형을 저장할 수도 있습니다.Duration ★★★★★★★★★★★★★★★★★」Period첫 번째는 기본적으로 TimeSpan과 동일하지만, 후자는 다른 날짜나 달이 길거나 짧다는 점을 고려합니다(즉, 다른 날짜보다 짧습니다).1월 31일, 2월 28일 29일서머타임이 있기 때문에 더 길거나 짧은 날이 있습니다).TimeSpan 을spanspan을을을spanspan 。

이 코드를 사용하여 기간을 변환할 수 있습니다.

using NodaTime;
using NodaTime.Serialization.JsonNet;

internal static class PeriodExtensions
{
    public static Period ToPeriod(this string input)
    {
        var js = JsonSerializer.Create(new JsonSerializerSettings());
        js.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
        var quoted = string.Concat(@"""", input, @"""");
        return js.Deserialize<Period>(new JsonTextReader(new StringReader(quoted)));
    }
}

그 다음에 이렇게 쓰면

public string ValidityPeriod { get; set; }

[NotMapped]
public Period ValidityPeriodPeriod
{
    get => ValidityPeriod.ToPeriod();
    set => ValidityPeriod = value.ToString();
}

는 말아를 매우 .NodaTime그리고 그것은 종종 나를 까다로운 벌레와 많은 두통으로부터 구해준다.단점은 SQL 쿼리에서 사용할 수 없고 메모리 내에서 계산을 수행해야 한다는 것입니다.

CLR 사용자 정의 유형

.TimeSpan직접 수업합니다.자세한 내용은 CLR 사용자 정의 유형을 참조하십시오.

단점은 SQL 보고서에서 데이터 유형이 제대로 작동하지 않을 수 있다는 것입니다.또한 SQL Server 일부 버전(Azure, Linux, Data Warehouse)은 지원되지 않습니다.

가치 변환

Entity Framework Core 2.1부터는 값 변환을 사용할 수 있는 옵션이 있습니다.

그러나 이 기능을 사용하면 EF는 많은 쿼리를 SQL로 변환할 수 없기 때문에 쿼리가 메모리 내에서 실행되어 수많은 데이터가 애플리케이션에 전송될 수 있습니다.

따라서 적어도 지금은 사용하지 않고 쿼리 결과를 Automapper로 매핑하는 것이 좋습니다.

오래된 질문인 건 알지만 몇 가지 다른 선택사항이 있는지 확인하고 싶었어요.

time sql data type 필드에 TimeSpan을 24시간 이상 저장할 수 없기 때문에 몇 가지 다른 옵션이 있을 수 있습니다.

  1. varchar(xx)를 사용하여 TimeSpan의 ToString을 저장합니다.이 방법의 이점은 정밀도를 데이터 유형이나 계산에 포함할 필요가 없다는 것입니다(초 대 밀리초 대 일 대 2 주). TimeSpan만 사용하면 됩니다.해석/TryParse.난 이렇게 할 거야

  2. 첫 번째 날짜 + 시간 범위의 결과를 저장하는 두 번째 날짜(datetime 또는 datetime offset)를 사용합니다.DB에서 읽는 것은 TimeSpan x = SecondDate - FirstDate의 문제입니다.이 옵션을 사용하면 이외의 다른 옵션으로부터 보호할 수 있습니다.NET 데이터 액세스 라이브러리는 동일한 데이터에 액세스하지만 TimeSpan을 이해하지 못합니다. 이러한 환경이 있는 경우입니다.

EF 하면 "EF Core"에서 데이터 할 수 AppDbContext

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
      // i.e. Store TimeSpan as string (custom)
      modelBuilder
        .Entity<YourClass>()
        .Property(x => x.YourTimeSpan)
        .HasConversion(
            timeSpan => timeSpan.ToString(), // To DB
            timeSpanString => TimeSpan.Parse(timeSpanString) // From DB
        );

    // i.e. Store TimeSpan as string (using TimeSpanToStringConverter)
    modelBuilder
        .Entity<YourClass>()
        .Property(x => x.YourTimeSpan)
        .HasConversion(new TimeSpanToStringConverter());

      // i.e. Store TimeSpan as number of ticks (custom)
      modelBuilder
        .Entity<YourClass>()
        .Property(x => x.YourTimeSpan)
        .HasConversion(
            timeSpan => timeSpan.Ticks, // To DB
            timeSpanString => TimeSpan.FromTicks(timeSpanString) // From DB
        );

    // i.e. Store TimeSpan as number of ticks (using TimeSpanToTicksConverter)
    modelBuilder
        .Entity<YourClass>()
        .Property(x => x.YourTimeSpan)
        .HasConversion(new TimeSpanToTicksConverter());
}

범위의 가장 또는 시간 와되게 하기 위해를할 수 . 물 netTimeSpan Server DateTime

의 SQL Server의 의 차이이기 때문입니다.DateTime표준)Cast로로 합니다.Float 그 다음 。Cast으로 DateTime한 )입니다.DateTime1900년1월1일과예: +0.1초의 차이는 1900년 1월 1일 00:00:00.100, -0.1초의 차이는 1899년 12월 31일 23:59:59.900입니다.

를하려면 , 「NET」를 해 주세요.TimeSpan에 접속합니다.DateTime.를합입다 a a a a 합니다.처음에는 로 변환됩니다. 물 netDateTime 입력합니다.DateTime19001900년1월 의 1월 1일의 1월 1일의 1월 1일의 1월 1일의 1일의 1월 1일의 1월 1일의 1월 1일의 1월 1일의 1월 1일의1일.SQL Server의 NET. 물 netDateTime.1900으로 합니다. 물 netTimeSpan.

Server SQL 에서 시간 예DateTime가 2016년 ( Server (T-SQL은 것도 없고)SQL Server (T-SQL)는 밀리초 단위로 이지 않을 수 Ticks）이(가) 있기 때문입니다Int은 「」입니다.DateDiff(vs.BigInt 2016의 SS 2016+에서 ★DateDiff_Big 및 후에 는 최대 24일 동안, 최대 67년 동안 오버플로우됩니다.한편, 이 솔루션에서는 0.1초까지의 시간 범위와 -147~+8,099년의 시간 범위를 정확하게 처리합니다.

경고:

  1. SQL Server의 내 이 1900년1월 1일1월 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1일 1DateTime1753년 1월~9999년 12월 31일, -147~+)할 필요가 에서는 그다지 걱정할 필요가 없습니다. 물 netTimeSpan29k~+29krs입니다. Server SQL Server에 하지 않았습니다.DateTime2 Server보다 큼)DateTime한 s)를 통해 할 수 때문입니다.Cast b) § b)DateTime님의 범위는 대부분의 사용 사례에 충분합니다.

  2. SQL ServerDateTime를 Cast ~에게 - ~에~Float - 0. 것 같습니다.- back - back 초 0.1초。

일반적으로 TimeSpan은 TimeSpan의 틱으로 채워진 bigint로 저장합니다.앞서 제안한 대로 속성을 체크 표시합니다.TimeSpan 출력으로 채워진 varchar(26)로 TimeSpan을 저장할 수도 있습니다.ToString() 입니다.작성한 4개의 스칼라 함수(ConvertFromTimeSpanString, ConvertToTimeSpanString, DateAddTicks, DateDiffTicks)는 SQL 측에서 TimeSpan을 처리하고 인위적으로 경계 범위를 생성하는 해크를 피하는 데 도움이 됩니다.간격을 에 저장할 수 있는 경우.NET TimeSpan은 이러한 기능에서도 동작합니다.또한 함수를 사용하면 를 포함하지 않는 기술을 사용하는 경우에도 TimeSpan 및 100나노초 틱을 사용할 수 있습니다.NET 프레임워크

DROP FUNCTION [dbo].[DateDiffTicks]
GO

DROP FUNCTION [dbo].[DateAddTicks]
GO

DROP FUNCTION [dbo].[ConvertToTimeSpanString]
GO

DROP FUNCTION [dbo].[ConvertFromTimeSpanString]
GO

SET ANSI_NULLS OFF
GO

SET QUOTED_IDENTIFIER OFF
GO

-- =============================================
-- Author:      James Coe
-- Create date: 2011-05-23
-- Description: Converts from a varchar(26) TimeSpan string to a bigint containing the number of 100 nanosecond ticks.
-- =============================================
/*
    [-][d.]hh:mm:ss[.fffffff] 

    "-" 
     A minus sign, which indicates a negative time interval. No sign is included for a positive time span.

    "d" 
     The number of days in the time interval. This element is omitted if the time interval is less than one day. 

    "hh" 
     The number of hours in the time interval, ranging from 0 to 23. 

    "mm" 
     The number of minutes in the time interval, ranging from 0 to 59. 

    "ss" 
     The number of seconds in the time interval, ranging from 0 to 59. 

    "fffffff" 
     Fractional seconds in the time interval. This element is omitted if the time interval does not include 
     fractional seconds. If present, fractional seconds are always expressed using seven decimal digits.
    */
CREATE FUNCTION [dbo].[ConvertFromTimeSpanString] (@timeSpan varchar(26))
RETURNS bigint
AS
BEGIN
    DECLARE @hourStart int
    DECLARE @minuteStart int
    DECLARE @secondStart int
    DECLARE @ticks bigint
    DECLARE @hours bigint
    DECLARE @minutes bigint
    DECLARE @seconds DECIMAL(9, 7)

    SET @hourStart = CHARINDEX('.', @timeSpan) + 1
    SET @minuteStart = CHARINDEX(':', @timeSpan) + 1
    SET @secondStart = CHARINDEX(':', @timespan, @minuteStart) + 1
    SET @ticks = 0

    IF (@hourStart > 1 AND @hourStart < @minuteStart)
    BEGIN
        SET @ticks = CONVERT(bigint, LEFT(@timespan, @hourstart - 2)) * 864000000000
    END
    ELSE
    BEGIN
        SET @hourStart = 1
    END

    SET @hours = CONVERT(bigint, SUBSTRING(@timespan, @hourStart, @minuteStart - @hourStart - 1))
    SET @minutes = CONVERT(bigint, SUBSTRING(@timespan, @minuteStart, @secondStart - @minuteStart - 1))
    SET @seconds = CONVERT(DECIMAL(9, 7), SUBSTRING(@timespan, @secondStart, LEN(@timeSpan) - @secondStart + 1))

    IF (@ticks < 0)
    BEGIN
        SET @ticks = @ticks - @hours * 36000000000
    END
    ELSE
    BEGIN
        SET @ticks = @ticks + @hours * 36000000000
    END

    IF (@ticks < 0)
    BEGIN
        SET @ticks = @ticks - @minutes * 600000000
    END
    ELSE
    BEGIN
        SET @ticks = @ticks + @minutes * 600000000
    END

    IF (@ticks < 0)
    BEGIN
        SET @ticks = @ticks - @seconds * 10000000.0
    END
    ELSE
    BEGIN
        SET @ticks = @ticks + @seconds * 10000000.0
    END

    RETURN @ticks
END
GO

-- =============================================
-- Author:      James Coe
-- Create date: 2011-05-23
-- Description: Converts from a bigint containing the number of 100 nanosecond ticks to a varchar(26) TimeSpan string.
-- =============================================
/*
[-][d.]hh:mm:ss[.fffffff] 

"-" 
 A minus sign, which indicates a negative time interval. No sign is included for a positive time span.

"d" 
 The number of days in the time interval. This element is omitted if the time interval is less than one day. 

"hh" 
 The number of hours in the time interval, ranging from 0 to 23. 

"mm" 
 The number of minutes in the time interval, ranging from 0 to 59. 

"ss" 
 The number of seconds in the time interval, ranging from 0 to 59. 

"fffffff" 
 Fractional seconds in the time interval. This element is omitted if the time interval does not include 
 fractional seconds. If present, fractional seconds are always expressed using seven decimal digits.
*/
CREATE FUNCTION [dbo].[ConvertToTimeSpanString] (@ticks bigint)
RETURNS varchar(26)
AS
BEGIN
    DECLARE @timeSpanString varchar(26)

    IF (@ticks < 0)
    BEGIN
        SET @timeSpanString = '-'
    END
    ELSE
    BEGIN
        SET @timeSpanString = ''
    END

    -- Days
    DECLARE @days bigint

    SET @days = FLOOR(ABS(@ticks / 864000000000.0))

    IF (@days > 0)
    BEGIN
        SET @timeSpanString = @timeSpanString + CONVERT(varchar(26), @days) + '.'
    END

    SET @ticks = ABS(@ticks % 864000000000)
    -- Hours
    SET @timeSpanString = @timeSpanString + RIGHT('0' + CONVERT(varchar(26), FLOOR(@ticks / 36000000000.0)), 2) + ':'
    SET @ticks = @ticks % 36000000000
    -- Minutes
    SET @timeSpanString = @timeSpanString + RIGHT('0' + CONVERT(varchar(26), FLOOR(@ticks / 600000000.0)), 2) + ':'
    SET @ticks = @ticks % 600000000
    -- Seconds
    SET @timeSpanString = @timeSpanString + RIGHT('0' + CONVERT(varchar(26), FLOOR(@ticks / 10000000.0)), 2)
    SET @ticks = @ticks % 10000000

    -- Fractional Seconds
    IF (@ticks > 0)
    BEGIN
        SET @timeSpanString = @timeSpanString + '.' + LEFT(CONVERT(varchar(26), @ticks) + '0000000', 7)
    END

    RETURN @timeSpanString
END
GO

-- =============================================
-- Author:      James Coe
-- Create date: 2011-05-23
-- Description: Adds the specified number of 100 nanosecond ticks to a date.
-- =============================================
CREATE FUNCTION [dbo].[DateAddTicks] (
    @ticks bigint
    , @starting_date datetimeoffset
    )
RETURNS datetimeoffset
AS
BEGIN
    DECLARE @dateTimeResult datetimeoffset

    IF (@ticks < 0)
    BEGIN
        -- Hours
        SET @dateTimeResult = DATEADD(HOUR, CEILING(@ticks / 36000000000.0), @starting_date)
        SET @ticks = @ticks % 36000000000
        -- Seconds
        SET @dateTimeResult = DATEADD(SECOND, CEILING(@ticks / 10000000.0), @dateTimeResult)
        SET @ticks = @ticks % 10000000
        -- Nanoseconds
        SET @dateTimeResult = DATEADD(NANOSECOND, @ticks * 100, @dateTimeResult)
    END
    ELSE
    BEGIN
        -- Hours
        SET @dateTimeResult = DATEADD(HOUR, FLOOR(@ticks / 36000000000.0), @starting_date)
        SET @ticks = @ticks % 36000000000
        -- Seconds
        SET @dateTimeResult = DATEADD(SECOND, FLOOR(@ticks / 10000000.0), @dateTimeResult)
        SET @ticks = @ticks % 10000000
        -- Nanoseconds
        SET @dateTimeResult = DATEADD(NANOSECOND, @ticks * 100, @dateTimeResult)
    END

    RETURN @dateTimeResult
END
GO

-- =============================================
-- Author:      James Coe
-- Create date: 2011-05-23
-- Description:  Gets the difference between two dates in 100 nanosecond ticks.
-- =============================================
CREATE FUNCTION [dbo].[DateDiffTicks] (
    @starting_date datetimeoffset
    , @ending_date datetimeoffset
    )
RETURNS bigint
AS
BEGIN
    DECLARE @ticks bigint
    DECLARE @days bigint
    DECLARE @hours bigint
    DECLARE @minutes bigint
    DECLARE @seconds bigint

    SET @hours = DATEDIFF(HOUR, @starting_date, @ending_date)
    SET @starting_date = DATEADD(HOUR, @hours, @starting_date)
    SET @ticks = @hours * 36000000000
    SET @seconds = DATEDIFF(SECOND, @starting_date, @ending_date)
    SET @starting_date = DATEADD(SECOND, @seconds, @starting_date)
    SET @ticks = @ticks + @seconds * 10000000
    SET @ticks = @ticks + CONVERT(bigint, DATEDIFF(NANOSECOND, @starting_date, @ending_date)) / 100

    RETURN @ticks
END
GO

--- BEGIN Test Harness ---
SET NOCOUNT ON

DECLARE @dateTimeOffsetMinValue datetimeoffset
DECLARE @dateTimeOffsetMaxValue datetimeoffset
DECLARE @timeSpanMinValueString varchar(26)
DECLARE @timeSpanZeroString varchar(26)
DECLARE @timeSpanMaxValueString varchar(26)
DECLARE @timeSpanMinValueTicks bigint
DECLARE @timeSpanZeroTicks bigint
DECLARE @timeSpanMaxValueTicks bigint
DECLARE @dateTimeOffsetMinMaxDiffTicks bigint
DECLARE @dateTimeOffsetMaxMinDiffTicks bigint

SET @dateTimeOffsetMinValue = '0001-01-01T00:00:00.0000000+00:00'
SET @dateTimeOffsetMaxValue = '9999-12-31T23:59:59.9999999+00:00'
SET @timeSpanMinValueString = '-10675199.02:48:05.4775808'
SET @timeSpanZeroString = '00:00:00'
SET @timeSpanMaxValueString = '10675199.02:48:05.4775807'
SET @timeSpanMinValueTicks = -9223372036854775808
SET @timeSpanZeroTicks = 0
SET @timeSpanMaxValueTicks = 9223372036854775807
SET @dateTimeOffsetMinMaxDiffTicks = 3155378975999999999
SET @dateTimeOffsetMaxMinDiffTicks = -3155378975999999999

-- TimeSpan Conversion Tests
PRINT 'Testing TimeSpan conversions...'

DECLARE @convertToTimeSpanStringMinTicksResult varchar(26)
DECLARE @convertFromTimeSpanStringMinTimeSpanResult bigint
DECLARE @convertToTimeSpanStringZeroTicksResult varchar(26)
DECLARE @convertFromTimeSpanStringZeroTimeSpanResult bigint
DECLARE @convertToTimeSpanStringMaxTicksResult varchar(26)
DECLARE @convertFromTimeSpanStringMaxTimeSpanResult bigint

SET @convertToTimeSpanStringMinTicksResult = dbo.ConvertToTimeSpanString(@timeSpanMinValueTicks)
SET @convertFromTimeSpanStringMinTimeSpanResult = dbo.ConvertFromTimeSpanString(@timeSpanMinValueString)
SET @convertToTimeSpanStringZeroTicksResult = dbo.ConvertToTimeSpanString(@timeSpanZeroTicks)
SET @convertFromTimeSpanStringZeroTimeSpanResult = dbo.ConvertFromTimeSpanString(@timeSpanZeroString)
SET @convertToTimeSpanStringMaxTicksResult = dbo.ConvertToTimeSpanString(@timeSpanMaxValueTicks)
SET @convertFromTimeSpanStringMaxTimeSpanResult = dbo.ConvertFromTimeSpanString(@timeSpanMaxValueString)

-- Test Results
SELECT 'Convert to TimeSpan String from Ticks (Minimum)' AS Test
    , CASE 
        WHEN @convertToTimeSpanStringMinTicksResult = @timeSpanMinValueString
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @timeSpanMinValueTicks AS [Ticks]
    , CONVERT(varchar(26), NULL) AS [TimeSpan String]
    , CONVERT(varchar(26), @convertToTimeSpanStringMinTicksResult) AS [Actual Result]
    , CONVERT(varchar(26), @timeSpanMinValueString) AS [Expected Result]
UNION ALL
SELECT 'Convert from TimeSpan String to Ticks (Minimum)' AS Test
    , CASE 
        WHEN @convertFromTimeSpanStringMinTimeSpanResult = @timeSpanMinValueTicks
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , NULL AS [Ticks]
    , @timeSpanMinValueString AS [TimeSpan String]
    , CONVERT(varchar(26), @convertFromTimeSpanStringMinTimeSpanResult) AS [Actual Result]
    , CONVERT(varchar(26), @timeSpanMinValueTicks) AS [Expected Result]
UNION ALL
SELECT 'Convert to TimeSpan String from Ticks (Zero)' AS Test
    , CASE 
        WHEN @convertToTimeSpanStringZeroTicksResult = @timeSpanZeroString
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @timeSpanZeroTicks AS [Ticks]
    , CONVERT(varchar(26), NULL) AS [TimeSpan String]
    , CONVERT(varchar(26), @convertToTimeSpanStringZeroTicksResult) AS [Actual Result]
    , CONVERT(varchar(26), @timeSpanZeroString) AS [Expected Result]
UNION ALL
SELECT 'Convert from TimeSpan String to Ticks (Zero)' AS Test
    , CASE 
        WHEN @convertFromTimeSpanStringZeroTimeSpanResult = @timeSpanZeroTicks
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , NULL AS [Ticks]
    , @timeSpanZeroString AS [TimeSpan String]
    , CONVERT(varchar(26), @convertFromTimeSpanStringZeroTimeSpanResult) AS [Actual Result]
    , CONVERT(varchar(26), @timeSpanZeroTicks) AS [Expected Result]
UNION ALL
SELECT 'Convert to TimeSpan String from Ticks (Maximum)' AS Test
    , CASE 
        WHEN @convertToTimeSpanStringMaxTicksResult = @timeSpanMaxValueString
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @timeSpanMaxValueTicks AS [Ticks]
    , CONVERT(varchar(26), NULL) AS [TimeSpan String]
    , CONVERT(varchar(26), @convertToTimeSpanStringMaxTicksResult) AS [Actual Result]
    , CONVERT(varchar(26), @timeSpanMaxValueString) AS [Expected Result]
UNION ALL
SELECT 'Convert from TimeSpan String to Ticks (Maximum)' AS Test
    , CASE 
        WHEN @convertFromTimeSpanStringMaxTimeSpanResult = @timeSpanMaxValueTicks
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , NULL AS [Ticks]
    , @timeSpanMaxValueString AS [TimeSpan String]
    , CONVERT(varchar(26), @convertFromTimeSpanStringMaxTimeSpanResult) AS [Actual Result]
    , CONVERT(varchar(26), @timeSpanMaxValueTicks) AS [Expected Result]

-- Ticks Date Add Test
PRINT 'Testing DateAddTicks...'

DECLARE @DateAddTicksPositiveTicksResult datetimeoffset
DECLARE @DateAddTicksZeroTicksResult datetimeoffset
DECLARE @DateAddTicksNegativeTicksResult datetimeoffset

SET @DateAddTicksPositiveTicksResult = dbo.DateAddTicks(@dateTimeOffsetMinMaxDiffTicks, @dateTimeOffsetMinValue)
SET @DateAddTicksZeroTicksResult = dbo.DateAddTicks(@timeSpanZeroTicks, @dateTimeOffsetMinValue)
SET @DateAddTicksNegativeTicksResult = dbo.DateAddTicks(@dateTimeOffsetMaxMinDiffTicks, @dateTimeOffsetMaxValue)

-- Test Results
SELECT 'Date Add with Ticks Test (Positive)' AS Test
    , CASE 
        WHEN @DateAddTicksPositiveTicksResult = @dateTimeOffsetMaxValue
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @dateTimeOffsetMinMaxDiffTicks AS [Ticks]
    , @dateTimeOffsetMinValue AS [Starting Date]
    , @DateAddTicksPositiveTicksResult AS [Actual Result]
    , @dateTimeOffsetMaxValue AS [Expected Result]
UNION ALL
SELECT 'Date Add with Ticks Test (Zero)' AS Test
    , CASE 
        WHEN @DateAddTicksZeroTicksResult = @dateTimeOffsetMinValue
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @timeSpanZeroTicks AS [Ticks]
    , @dateTimeOffsetMinValue AS [Starting Date]
    , @DateAddTicksZeroTicksResult AS [Actual Result]
    , @dateTimeOffsetMinValue AS [Expected Result]
UNION ALL
SELECT 'Date Add with Ticks Test (Negative)' AS Test
    , CASE 
        WHEN @DateAddTicksNegativeTicksResult = @dateTimeOffsetMinValue
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @dateTimeOffsetMaxMinDiffTicks AS [Ticks]
    , @dateTimeOffsetMaxValue AS [Starting Date]
    , @DateAddTicksNegativeTicksResult AS [Actual Result]
    , @dateTimeOffsetMinValue AS [Expected Result]

-- Ticks Date Diff Test
PRINT 'Testing Date Diff Ticks...'

DECLARE @dateDiffTicksMinMaxResult bigint
DECLARE @dateDiffTicksMaxMinResult bigint

SET @dateDiffTicksMinMaxResult = dbo.DateDiffTicks(@dateTimeOffsetMinValue, @dateTimeOffsetMaxValue)
SET @dateDiffTicksMaxMinResult = dbo.DateDiffTicks(@dateTimeOffsetMaxValue, @dateTimeOffsetMinValue)

-- Test Results
SELECT 'Date Difference in Ticks Test (Min, Max)' AS Test
    , CASE 
        WHEN @dateDiffTicksMinMaxResult = @dateTimeOffsetMinMaxDiffTicks
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @dateTimeOffsetMinValue AS [Starting Date]
    , @dateTimeOffsetMaxValue AS [Ending Date]
    , @dateDiffTicksMinMaxResult AS [Actual Result]
    , @dateTimeOffsetMinMaxDiffTicks AS [Expected Result]
UNION ALL
SELECT 'Date Difference in Ticks Test (Max, Min)' AS Test
    , CASE 
        WHEN @dateDiffTicksMaxMinResult = @dateTimeOffsetMaxMinDiffTicks
            THEN 'Pass'
        ELSE 'Fail'
        END AS [Test Status]
    , @dateTimeOffsetMaxValue AS [Starting Date]
    , @dateTimeOffsetMinValue AS [Ending Date]
    , @dateDiffTicksMaxMinResult AS [Actual Result]
    , @dateTimeOffsetMaxMinDiffTicks AS [Expected Result]

PRINT 'Tests Complete.'
GO
--- END Test Harness ---

시간 간격을 저장할 거예요.플로트 내의 TotalSeconds를 지정한 후 타임스팬을 사용하여 가져옵니다.FromSeconds(totalSeconds).

필요한 해상도에 따라 Total Milliseconds, Total Minutes, Total Days를 사용할 수 있습니다.

데이터베이스에서 플로트의 정밀도를 조정할 수도 있습니다.

정확한 값이 아니라...단, 간단한 질의로 쉽게 읽고 계산할 수 있다는 장점이 있습니다.

언급URL : https://stackoverflow.com/questions/8503825/what-is-the-correct-sql-type-to-store-a-net-timespan-with-values-240000

'programing' 카테고리의 다른 글

SQL Server 언더스코어 이스케이프  (0) 2023.04.07
모든 테이블, 모든 열에서 특정 값 SQL Server 검색  (0) 2023.04.07
CASE 문을 JOIN 조건으로 사용할 수 있습니까?  (0) 2023.04.07
SQL Server에 테이블이 있는지 확인합니다.  (0) 2023.04.07
SQL Server 2005 데이터베이스에 대한 현재 연결을 모두 끊으려면 어떻게 해야 합니까?  (0) 2023.04.07

'programing'의 다른글

  • 현재글를 저장하기 위한 올바른 SQL 유형은 무엇입니까?값이 24:00:00보다 큰 Net Timespan?

관련글

댓글

티스토리툴바