Datatype for System.Version in sql server

Question

What is the best way to store System.Version in SQL Server?

When I use varchar type, result of order by asc is:

1.0.0.0
11.0.0.0
12.0.0.0
2.0.0.0

Rigorous

+1 for the good Question – Sukkoth

Do you have any other relevant column which could help in ordering the versions ? – Jot

@Jot no I don't have it – Rigorous

Answer 1

you can use a varchar column

you could order like this

SELECT *
FROM t_version 
ORDER BY CAST('/' + vid + '/' AS HIERARCHYID)

SQL fiddle is not working today , other wise I could have showed a demo

Please run this for testing

 SELECT * FROM 
( VALUES 
        ( '1.0.0.0' ),
        ( '11.0.0.0' ),
        ('12.0.0.0'),
        ('2.0.0.0') ) AS vid ( vid ) 
ORDER BY CAST('/' + vid + '/' AS HIERARCHYID)

Yingling

Tip: you can more easily use VALUES instead of UNION ALL for demonstration answers: SELECT * FROM ( VALUES ( '1.0.0.0' ), ( '11.0.0.0' ) ... ) AS vid ( vid ) ORDER BY ... – Elegancy

@hvd I normally refrain unless the question is tagged sql-server-2008, or 2012 – Switchman

@Switchman Fair point, but HIERARCHYID already requires SQL Server 2008 :) – Elegancy

Answer 2

Just store it as a normal varchar, which is good for versions up to 4 parts using PARSENAME to split the string and order by 4 separate columns.

i.e.

ORDER BY PARSENAME(version,4),
         PARSENAME(version,3),
         PARSENAME(version,2),
         PARSENAME(version,1)

Switchman

Answer 3

To support ordering among mixed lengths versions (e.g. '1.2' vs '1.2.3.4'), a mapping to a decimal can be performed (as inline table valued functions).

create function Common.ufn_OrderableVersion(@pVersion nvarchar(100))
returns table
as
/*---------------------------------------------------------------------------------------------------------------------
    Purpose:  Provide a mapping from Versions of the form 'a.b.c.d', 'a.b.c, 'a.b', 'a', null to 
              an orderable decimal(25, 0) 

              Since Parsename() doesn't apply easily to mixed length comparisions (1.2 vs 1.2.3.4)

 Test Cases:
              select * from Common.ufn_OrderableVersion(null);       -- null
              select * from Common.ufn_OrderableVersion('0');        -- 1000000000000000000000000
              select * from Common.ufn_OrderableVersion('1');        -- 1000001000000000000000000
              select * from Common.ufn_OrderableVersion('1.2.3.4');  -- 1000001000002000003000004

              select Version
                from 
                   (
                      select '1.3.5.3' as Version
                      union all
                      select '1.2.5.3' as Version
                      union all
                      select '1.1.5.3' as Version
                      union all
                      select '1.3.5.2' as Version
                      union all
                      select null as Version
                      union all                      
                      select '' as Version
                      union all
                      select '2' as Version
                      union all
                      select '1.2' as Version
                      union all
                      select '1' as Version                      
                   ) v 
               order by (select Value from Common.ufn_OrderableVersion(Version))

    Modified    By              Description
    ----------  --------------  ---------------------------------------------------------------------------------------
    2015.08.24  crokusek        Initial Version
  ---------------------------------------------------------------------------------------------------------------------*/
return         
    -- 25 = 1 + VersionPositions * MaxDigitsPerSegment
    select convert(decimal(25,0), '1' + 
           stuff((select format(Value, '000000')
                    from 
                       (
                          select convert(int, Value) as Value, RowNumber 
                              -- Support empty string and partial versions. Null maps to null
                            from Common.ufn_SplitUsingXml(@pVersion + '.0.0.0.0', '.') -- pad right
                           where RowNumber <= 4 -- trim right
                       ) as v
                   order by RowNumber
                     for xml path ('')
                ), 1, 0, '')
           ) as Value
go

Dependency:

create function Common.ufn_SplitUsingXml
(
   @pList       nvarchar(max),
   @pDelimiter  nvarchar(255)
)
returns table
as
/*---------------------------------------------------------------------------------------------------------------------
    Purpose:  Split an Identifier using XML as an inline table valued function.  
              Using the SQL Server CLR (C#) capability would be the most efficient way to support this.

   Warnings:  Will not work if the input contains special XML characters like '<', '>' or '&'.
              Caller must add "option (maxrecursion 0)" for lists greater than 100 (it can't be added within the ufn)                  

    Modified    By              Description
    ----------  --------------  ---------------------------------------------------------------------------------------
    2015.08.24  inet            http://sqlperformance.com/2012/07/t-sql-queries/split-strings
  ---------------------------------------------------------------------------------------------------------------------*/
return 
(  
  select Value = y.i.value('(./text())[1]', 'nvarchar(4000)'),
         row_number() over (order by (select null)) as RowNumber 
  from 
  (  
    select x = convert(XML, '<i>' 
       + replace(@pList, @pDelimiter, '</i><i>') 
       + '</i>').query('.')
  ) AS a cross apply x.nodes('i') AS y(i)
  -- option (maxrecursion 0) must be added by caller for lists greater than 100
);
go

Comparison:

alter function Common.ufn_CompareVersions
(
   @pVersionA nvarchar(100),
   @pVersionB nvarchar(100)
)
returns table
as
/*---------------------------------------------------------------------------------------------------------------------
    Purpose:  Compare Version of the form 'A.B.C.D'.  
              Comparing versions of different lengths is also supported 'A.B'.

 Test Cases:
              select Result from Common.ufn_CompareVersions('1', null) -- 1
              select Result from Common.ufn_CompareVersions(null, '1') -- -1
              select Result from Common.ufn_CompareVersions('1', '1') -- 0
              select Result from Common.ufn_CompareVersions('1', '2') -- -1
              select Result from Common.ufn_CompareVersions('2', '1') -- 1
              select Result from Common.ufn_CompareVersions('1', '1.2') -- -1
              select Result from Common.ufn_CompareVersions('1.2', '1') -- 1
              select Result from Common.ufn_CompareVersions('1.2.3.4', '1.2.3.4') -- 0
              select Result from Common.ufn_CompareVersions('1.2.3', '1.2.3.4') -- -1
              select Result from Common.ufn_CompareVersions('1.2.3.4', '1.2.3') -- 1
              select Result from Common.ufn_CompareVersions('1.9.3.4', '1.2.3.4') -- 1
              select Result from Common.ufn_CompareVersions('1.2.3.4', '1.9.3.4') -- -1
              select Result from Common.ufn_CompareVersions('1.002', '1.2') -- 0
              select Result from Common.ufn_CompareVersions('1.2', '1.2.0') -- 0

    Modified    By           Description
    ----------  -----------  ------------------------------------------------------------------------------------------
    2015.08.24  crokusek     Initial Version
  ---------------------------------------------------------------------------------------------------------------------*/
return    
    with Compares as
    (
      select (select IsNull(Value, 0) from Common.ufn_OrderableVersion(@pVersionA)) as A,
             (select IsNull(Value, 0) from Common.ufn_OrderableVersion(@pVersionB)) as B
    )
    select case when A > B then 1
                when A < B then -1
                else 0
           end as Result
      from Compares
go

Flavory