Как сравнить версии программного обеспечения с помощью SQL Server?
При попытке сравнить версии программного обеспечения с 5.12 по 5.8 версия 5.12 новее, однако математически 5.12 меньше 5.8. Как бы сравнить две версии, чтобы более новая версия вернула "Y"?
SELECT CASE WHEN 5.12 > 5.8 THEN 'Y' ELSE 'N' END
Возможные решения
- Добавьте 0 после десятичного числа в 5.8, чтобы он сравнивал 5.08-5.12, однако, похоже, для этого потребуется немного кода.
- Просто сравните значения после десятичной (т.е. 12 > 8), однако это не удается, когда версия переместится в 6.0.
- Используйте обратную логику и предположим, что если 5.12 меньше 5.8, то для возврата "Y". Я считаю, что это закончилось бы неудачей, когда версия переместится в 6.0.
Ответы
Ответ 1
declare @v1 varchar(100) = '5.12'
declare @v2 varchar(100) = '5.8'
select
case
when CONVERT(int, LEFT(@v1, CHARINDEX('.', @v1)-1)) < CONVERT(int, LEFT(@v2, CHARINDEX('.', @v2)-1)) then 'v2 is newer'
when CONVERT(int, LEFT(@v1, CHARINDEX('.', @v1)-1)) > CONVERT(int, LEFT(@v2, CHARINDEX('.', @v2)-1)) then 'v1 is newer'
when CONVERT(int, substring(@v1, CHARINDEX('.', @v1)+1, LEN(@v1))) < CONVERT(int, substring(@v2, CHARINDEX('.', @v2)+1, LEN(@v1))) then 'v2 is newer'
when CONVERT(int, substring(@v1, CHARINDEX('.', @v1)+1, LEN(@v1))) > CONVERT(int, substring(@v2, CHARINDEX('.', @v2)+1, LEN(@v1))) then 'v1 is newer'
else 'same!'
end
Ответ 2
Я рекомендую создать функцию CLR SQL:
public partial class UserDefinedFunctions
{
[SqlFunction(Name = "CompareVersion")]
public static bool CompareVersion(SqlString x, SqlString y)
{
return Version.Parse(x) > Version.Parse(y);
}
}
Примечания:
- SqlString имеет явное приведение в строку.
- Пропустить полную версию строки с
a.b.c.d
Ответ 3
Было очень хорошее решение по дублирующему вопросу:
Как сравнить строки SQL, содержащие номера версий, такие как класс .NET System.Version?
Поиграв с запросом какое-то время, я узнал, что он не смог сравнить последнюю часть, когда есть 4 или более частей (например, если номер версии был 1.2.3.4, он всегда будет обрабатывать последний как 0). Я исправил эту проблему, а также придумал другую функцию для сравнения двух номеров версий.
CREATE Function [dbo].[VersionNthPart](@version as nvarchar(max), @part as int) returns int as
Begin
Declare
@ret as int = null,
@start as int = 1,
@end as int = 0,
@partsFound as int = 0,
@terminate as bit = 0
if @version is not null
Begin
Set @ret = 0
while @partsFound < @part
Begin
Set @end = charindex('.', @version, @start)
If @end = 0 -- did not find the dot. Either it was last part or the part was missing.
begin
if @part - @partsFound > 1 -- also this isn't the last part so it must bail early.
begin
set @terminate = 1
end
Set @partsFound = @part
SET @end = len(@version) + 1; -- get the full length so that it can grab the whole of the final part.
end
else
begin
SET @partsFound = @partsFound + 1
end
If @partsFound = @part and @terminate = 0
begin
Set @ret = Convert(int, substring(@version, @start, @end - @start))
end
Else
begin
Set @start = @end + 1
end
End
End
return @ret
End
GO
CREATE FUNCTION [dbo].[CompareVersionNumbers]
(
@Source nvarchar(max),
@Target nvarchar(max),
@Parts int = 4
)
RETURNS INT
AS
BEGIN
/*
-1 : target has higher version number (later version)
0 : same
1 : source has higher version number (later version)
*/
DECLARE @ReturnValue as int = 0;
DECLARE @PartIndex as int = 1;
DECLARE @SourcePartValue as int = 0;
DECLARE @TargetPartValue as int = 0;
WHILE (@PartIndex <= @Parts AND @ReturnValue = 0)
BEGIN
SET @SourcePartValue = [dbo].[VersionNthPart](@Source, @PartIndex);
SET @TargetPartValue = [dbo].[VersionNthPart](@Target, @PartIndex);
IF @SourcePartValue > @TargetPartValue
SET @ReturnValue = 1
ELSE IF @SourcePartValue < @TargetPartValue
SET @ReturnValue = -1
SET @PartIndex = @PartIndex + 1;
END
RETURN @ReturnValue
END
Использование/тестовый пример:
declare @Source as nvarchar(100) = '4.9.21.018'
declare @Target as nvarchar(100) = '4.9.21.180'
SELECT [dbo].[CompareVersionNumbers](@Source, @Target, DEFAULT) -- default version parts are 4
SET @Source = '1.0.4.1'
SET @Target = '1.0.1.8'
SELECT [dbo].[CompareVersionNumbers](@Source, @Target, 4) -- typing out # of version parts also works
SELECT [dbo].[CompareVersionNumbers](@Source, @Target, 2) -- comparing only 2 parts should be the same
SET @Target = '1.0.4.1.5'
SELECT [dbo].[CompareVersionNumbers](@Source, @Target, 4) -- only comparing up to parts 4 so they are the same
SELECT [dbo].[CompareVersionNumbers](@Source, @Target, 5) -- now comparing 5th part which should indicate that the target has higher version number
Ответ 4
Два шага, сначала сравните левую часть десятичной точки и после этого сравните правую.
Возможное решение:
declare @v1 varchar(100) = '5.12'
declare @v2 varchar(100) = '5.8'
select case
when CONVERT(int, LEFT(@v1, CHARINDEX('.', @v1)-1)) < CONVERT(int, LEFT(@v2, CHARINDEX('.', @v2)-1)) then 'v2 is newer'
when CONVERT(int, LEFT(@v1, CHARINDEX('.', @v1)-1)) > CONVERT(int, LEFT(@v2, CHARINDEX('.', @v2)-1)) then 'v1 is newer'
when CONVERT(int, RIGHT(@v1, LEN(@v1) - CHARINDEX('.', @v1))) < CONVERT(int, RIGHT(@v2, LEN(@v2) - CHARINDEX('.', @v2))) then 'v2 is newer'
when CONVERT(int, RIGHT(@v1, LEN(@v1) - CHARINDEX('.', @v1))) > CONVERT(int, RIGHT(@v2, LEN(@v2) - CHARINDEX('.', @v2))) then 'v1 is newer'
else 'same!' end as 'Version Test'
Ответ 5
Я столкнулся с этим при попытке фильтровать строки SQL на основе семантического управления версиями. Мое решение было несколько иным, поскольку я хотел сохранить строки конфигурации, помеченные семантическим номером версии, а затем выбрать строки, совместимые с текущей версией нашего программного обеспечения.
Предположения:
- Мое программное обеспечение будет включать настройку конфигурации, содержащую текущий номер версии
- Строки конфигурации, основанные на данных, будут содержать номер версии min
- Мне нужно иметь возможность выбирать строки конфигурации, где min <= current.
Примеры:
- Версия 1.0.0 должна включать: 1.0.0, 1.0.0- *, 1.0.0-beta.1
- Версия 1.0.0 должна исключать: 1.0.1, 1.1.0, 2.0.0
- Версия 1.1.0-beta.2 должна включать: 1.0.0, 1.0.1, 1.1.0-beta.1, 1.1.0-beta.2
- Версия 1.1.0-beta.2 должна исключать: 1.1.0, 1.1.1, 1.2.0, 2.0.0, 1.1.1-beta.1
MSSQL UDF:
CREATE FUNCTION [dbo].[SemanticVersion] (
@Version nvarchar(50)
)
RETURNS nvarchar(255)
AS
BEGIN
DECLARE @hyphen int = CHARINDEX('-', @version)
SET @Version = REPLACE(@Version, '*', ' ')
DECLARE
@left nvarchar(50) = CASE @hyphen WHEN 0 THEN @version ELSE SUBSTRING(@version, 1, @hyphen-1) END,
@right nvarchar(50) = CASE @hyphen WHEN 0 THEN NULL ELSE SUBSTRING(@version, @hyphen+1, 50) END,
@normalized nvarchar(255) = '',
@buffer int = 8
WHILE CHARINDEX('.', @left) > 0 BEGIN
SET @normalized = @normalized + CASE ISNUMERIC(LEFT(@left, CHARINDEX('.', @left)-1))
WHEN 0 THEN LEFT(@left, CHARINDEX('.', @left)-1)
WHEN 1 THEN REPLACE(STR(LEFT(@left, CHARINDEX('.', @left)-1), @buffer), SPACE(1), '0')
END + '.'
SET @left = SUBSTRING(@left, CHARINDEX('.', @left)+1, 50)
END
SET @normalized = @normalized + CASE ISNUMERIC(@left)
WHEN 0 THEN @left
WHEN 1 THEN REPLACE(STR(@left, @buffer), SPACE(1), '0')
END
SET @normalized = @normalized + '-'
IF (@right IS NOT NULL) BEGIN
WHILE CHARINDEX('.', @right) > 0 BEGIN
SET @normalized = @normalized + CASE ISNUMERIC(LEFT(@right, CHARINDEX('.', @right)-1))
WHEN 0 THEN LEFT(@right, CHARINDEX('.', @right)-1)
WHEN 1 THEN REPLACE(STR(LEFT(@right, CHARINDEX('.', @right)-1), @buffer), SPACE(1), '0')
END + '.'
SET @right = SUBSTRING(@right, CHARINDEX('.', @right)+1, 50)
END
SET @normalized = @normalized + CASE ISNUMERIC(@right)
WHEN 0 THEN @right
WHEN 1 THEN REPLACE(STR(@right, @buffer), SPACE(1), '0')
END
END ELSE
SET @normalized = @normalized + 'zzzzzzzzzz'
RETURN @normalized
END
SQL-тесты включают в себя:
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-alpha') < dbo.SemanticVersion('1.0.0-alpha.1') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-alpha.1') < dbo.SemanticVersion('1.0.0-alpha.beta') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-alpha.beta') < dbo.SemanticVersion('1.0.0-beta') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-beta') < dbo.SemanticVersion('1.0.0-beta.2') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-beta.2') < dbo.SemanticVersion('1.0.0-beta.11') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-beta.11') < dbo.SemanticVersion('1.0.0-rc.1') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-rc.1') < dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-*') <= dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.*') <= dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.*') <= dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('*') <= dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.0-*') <= dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.1-*') > dbo.SemanticVersion('1.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.0.1-*') <= dbo.SemanticVersion('1.0.1') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.1.*') > dbo.SemanticVersion('1.0.9') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.1.*') <= dbo.SemanticVersion('1.2.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.*') <= dbo.SemanticVersion('2.0.0') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('1.*') > dbo.SemanticVersion('0.9.9-beta-219') THEN 'Success' ELSE 'Failure' END
SELECT CASE WHEN dbo.SemanticVersion('*') <= dbo.SemanticVersion('0.0.1-alpha-1') THEN 'Success' ELSE 'Failure' END
Ответ 6
Не хранить в строке то, что не является строкой. Альтернатива создает собственный тип данных (в С# - допустимый на некоторое время), который хранит версии как последовательность байтов и реализует правильную логику сравнения.
Ответ 7
Как было предложено AF, вы можете сравнить часть int, а затем десятичную часть. Из всех полученных ответов есть еще один способ сделать это, используя parseame. Вы можете попробовать что-то вроде этого
case when cast(@var as int)>cast(@var2 as int) then 'Y'
when cast(PARSENAME(@var,1) as int) > cast(PARSENAME(@var2,1) as int) THEN 'Y'
Declare @var float
Declare @var2 float
set @var=5.14
set @var2=5.8
Select case when cast(@var as int)>cast(@var2 as int) then 'Y'
when cast(PARSENAME(@var,1) as int)> cast(PARSENAME(@var2,1) as int) THEN 'Y'
else 'N' END
Ответ 8
Вы не говорите об этом в вопросе, но ваш комментарий в ответ Tomtom говорит, что вы сохраняете номера версий как [десятичные числа] [d]. Я предполагаю, что у вас есть таблица вроде этого:
CREATE TABLE ReleaseHistory (
VersionNumber DECIMAL(6,3) NOT NULL
);
GO
INSERT INTO ReleaseHistory (
VersionNumber
)
VALUES
(5.12),
(5.8),
(12.34),
(3.14),
(0.78),
(1.0);
GO
Следующий запрос - попытка ранжировать версии по порядку, в котором они будут выпущены:
SELECT
VersionNumber,
RANK() OVER (ORDER BY VersionNumber) AS ReleaseOrder
FROM ReleaseHistory;
Он производит следующий результирующий набор:
VersionNumber ReleaseOrder
--------------------------------------- --------------------
0.780 1
1.000 2
3.140 3
5.120 4
5.800 5
12.340 6
Это не то, чего мы ожидаем. Версия 5.8 была выпущена до версии 5.12!
Разделите номер версии на основные и второстепенные компоненты, чтобы правильно ранжировать номера версий. Один из способов сделать это - преобразовать десятичное значение в строку и разделить на период. Синтаксис T-SQL для этого является уродливым (язык не предназначен для обработки строк):
WITH VersionStrings AS (
SELECT CAST(VersionNumber AS VARCHAR(6)) AS VersionString
FROM ReleaseHistory
),
VersionNumberComponents AS (
SELECT
CAST(SUBSTRING(VersionString, 1, CHARINDEX('.', VersionString) - 1) AS INT) AS MajorVersionNumber,
CAST(SUBSTRING(VersionString, CHARINDEX('.', VersionString) + 1, LEN(VersionString) - CHARINDEX('.', VersionString)) AS INT) AS MinorVersionNumber
FROM VersionStrings
)
SELECT
CAST(MajorVersionNumber AS VARCHAR(3)) + '.' + CAST(MinorVersionNumber AS VARCHAR(3)) AS VersionString,
RANK() OVER (ORDER BY MajorVersionNumber, MinorVersionNumber) AS ReleaseOrder
FROM VersionNumberComponents;
Но он обеспечивает ожидаемый результат:
VersionString ReleaseOrder
------------- --------------------
0.780 1
1.0 2
3.140 3
5.120 4
5.800 5
12.340 6
Как Tomtom ответил, десятичный код не является хорошим типом для хранения номера версии. Было бы лучше сохранить номер версии в двух положительных целочисленных столбцах, один из которых содержит номер основной версии, а другой - младший номер версии.
Ответ 9
Это основано на ответе SeanW, но это решение позволяет использовать следующий формат [major]. [minor]. [build]. Возможно, он используется для SQL 2K, и когда курсор не является опцией.
declare @v1 varchar(100) = '1.4.020'
declare @v2 varchar(100) = '1.4.003'
declare @v1_dot1_pos smallint /*position - 1st version - 1st dot */
declare @v1_dot2_pos smallint /*position - 1st version - 2nd dot */
declare @v2_dot1_pos smallint /*position - 2nd version - 1st dot */
declare @v2_dot2_pos smallint /*position - 2nd version - 2nd dot */
-------------------------------------------------
-- get the pos of the first and second dots
-------------------------------------------------
SELECT
@v1_dot1_pos=CHARINDEX('.', @v1),
@v2_dot1_pos=CHARINDEX('.', @v2),
@v1_dot2_pos=charindex( '.', @v1, charindex( '.', @v1 ) + 1 ),
@v2_dot2_pos=charindex( '.', @v2, charindex( '.', @v2 ) + 1 )
-------------------------------------------------
-- break down the parts
-------------------------------------------------
DECLARE @v1_major int, @v2_major int
DECLARE @v1_minor int, @v2_minor int
DECLARE @v1_build int, @v2_build int
SELECT
@v1_major = CONVERT(int,LEFT(@v1,@v1_dot1_pos-1)),
@v1_minor = CONVERT(int,SUBSTRING(@v1,@v1_dot1_pos+1,(@[email protected]_dot1_pos)-1)),
@v1_build = CONVERT(int,RIGHT(@v1,(LEN(@v1)[email protected]_dot2_pos))),
@v2_major = CONVERT(int,LEFT(@v2,@v2_dot1_pos-1)),
@v2_minor = CONVERT(int,SUBSTRING(@v2,@v2_dot1_pos+1,(@[email protected]_dot1_pos)-1)),
@v2_build = CONVERT(int,RIGHT(@v2,(LEN(@v2)[email protected]_dot2_pos)))
-------------------------------------------------
-- return the difference
-------------------------------------------------
SELECT
Case
WHEN @v1_major < @v2_major then 'v2 is newer'
WHEN @v1_major > @v2_major then 'v1 is newer'
WHEN @v1_minor < @v2_minor then 'v2 is newer'
WHEN @v1_minor > @v2_minor then 'v1 is newer'
WHEN @v1_build < @v2_build then 'v2 is newer'
WHEN @v1_build > @v2_build then 'v1 is newer'
ELSE '!Same'
END
Ответ 10
Решение, которое было реализовано:
CREATE FUNCTION [dbo].[version_compare]
(
@v1 VARCHAR(5), @v2 VARCHAR(5)
)
RETURNS tinyint
AS
BEGIN
DECLARE @v1_int tinyint, @v1_frc tinyint,
@v2_int tinyint, @v2_frc tinyint,
@ResultVar tinyint
SET @ResultVar = 0
SET @v1_int = CONVERT(tinyint, LEFT(@v1, CHARINDEX('.', @v1) - 1))
SET @v1_frc = CONVERT(tinyint, RIGHT(@v1, LEN(@v1) - CHARINDEX('.', @v1)))
SET @v2_int = CONVERT(tinyint, LEFT(@v2, CHARINDEX('.', @v2) - 1))
SET @v2_frc = CONVERT(tinyint, RIGHT(@v2, LEN(@v2) - CHARINDEX('.', @v2)))
SELECT @ResultVar = CASE
WHEN @v2_int > @v1_int THEN 2
WHEN @v1_int > @v2_int THEN 1
WHEN @v2_frc > @v1_frc THEN 2
WHEN @v1_frc > @v2_frc THEN 1
ELSE 0 END
-- Return the result of the function
RETURN @ResultVar
END
GO
Ответ 11
Вы можете использовать hierarchyid
Который вы можете использовать, положив / в конце и начале строки и произведя ее
например.
SELECT CASE WHEN cast('/5.12/' as hierarchyid) > cast('/5.8/' as hierarchyid) THEN 'Y' ELSE 'N' END
Это возвращает Y
Ответ 12
Вот что я сделал, изменив код, который я нашел на StackOverflow, и сам написал. Это версия 1 кода, поэтому, пожалуйста, дайте мне знать, что вы думаете. Примеры использования и тестовые примеры содержатся в комментариях кода.
Сначала создайте эту функцию, если не используете SQL 2016 или выше, и у вас нет доступа к STRING_SPLIT:
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author: <Author,,Name>
-- Create date: <Create Date,,>
-- Description: modified from https://stackoverflow.com/questions/10914576/t-sql-split-string/42000063#42000063
-- =============================================
CREATE FUNCTION [dbo].[SplitStringToRows]
(
@List VARCHAR(4000)
, @Delimiter VARCHAR(50)
)
RETURNS TABLE
AS
RETURN
(
--For testing
-- SELECT * FROM SplitStringToRows ('1.0.123','.')
-- DECLARE @List VARCHAR(MAX) = '1.0.123', @Delimiter VARCHAR(50) = '.';
WITH Casted AS
(
SELECT CAST(N'<x>' + REPLACE((SELECT REPLACE(@List,@Delimiter,N'§§Split$me$here§§') AS [*] FOR XML PATH('')),N'§§Split$me$here§§',N'</x><x>') + N'</x>' AS XML) AS SplitMe
)
SELECT ROW_NUMBER() OVER (ORDER BY (SELECT 0)) AS [Index]
, x.value(N'.',N'nvarchar(max)') AS Part
FROM Casted
CROSS APPLY SplitMe.nodes(N'/x') AS A(x)
)
Затем создайте эту функцию:
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author: Soenhay
-- Create date: 7/1/2017
-- Description: Returns -1 if VersionStringA is less than VersionStringB.
-- Returns 0 if VersionStringA equals VersionStringB.
-- Returns 1 if VersionSTringA is greater than VersionStringB.
-- =============================================
CREATE FUNCTION dbo.CompareVersionStrings
(
@VersionStringA VARCHAR(50)
,@VersionStringB VARCHAR(50)
)
RETURNS TABLE
AS
RETURN
(
--CurrentVersion should be of the form:
--major.minor[.build[.revision]]
--This is the same as the versioning system used in c#.
--For applications the build and revision numbers will by dynamically set based on the current date and time of the build.
--Example: [assembly: AssemblyFileVersion("1.123.*")]//http://stackoverflow.com/questions/15505841/the-version-specified-for-the-file-version-is-not-in-the-normal-major-minor-b
--Each component should be between 0 and 65534 ( UInt16.MaxValue - 1 )
--Max version number would be 65534.65534.65534.65534
--For Testing
-- SELECT * FROM dbo.CompareVersionStrings('', '')
-- SELECT * FROM dbo.CompareVersionStrings('asdf.asdf', 'asdf.asdf') --returns 0
-- SELECT * FROM dbo.CompareVersionStrings('asdf', 'fdas') --returns -1
-- SELECT * FROM dbo.CompareVersionStrings('zasdf', 'fdas') --returns 1
-- SELECT * FROM dbo.CompareVersionStrings('1.0.123.123', '1.1.123.123') --Should return -1
-- SELECT * FROM dbo.CompareVersionStrings('1.0.123.123', '1.0.123.123') --Should return 0
-- SELECT * FROM dbo.CompareVersionStrings('1.1.123.123', '1.0.123.123') --Should return 1
-- SELECT * FROM dbo.CompareVersionStrings('1.0.123.123', '1.0.124.123') --Should return -1
-- SELECT * FROM dbo.CompareVersionStrings('1.0.124.123', '1.0.123.123') --Should return 1
-- SELECT * FROM dbo.CompareVersionStrings('1.0.123.123', '1.0.123.124') --Should return -1
-- SELECT * FROM dbo.CompareVersionStrings('1.0.123.124', '1.0.123.123') --Should return 1
-- SELECT * FROM dbo.CompareVersionStrings('1.0', '1.1') --Should return -1
-- SELECT * FROM dbo.CompareVersionStrings('1.0', '1.0') --Should return 0
-- SELECT * FROM dbo.CompareVersionStrings('1.1', '1.0') --Should return 1
-- Declare @VersionStringA VARCHAR(50) = '' ,@VersionStringB VARCHAR(50) = '' ;
-- Declare @VersionStringA VARCHAR(50) = '1.0.123.123' ,@VersionStringB VARCHAR(50) = '1.1.123.123' ;
-- Declare @VersionStringA VARCHAR(50) = '1.1.123.123' ,@VersionStringB VARCHAR(50) = '1.1.123.123' ;
-- Declare @VersionStringA VARCHAR(50) = '1.2.123.123' ,@VersionStringB VARCHAR(50) = '1.1.123.123' ;
-- Declare @VersionStringA VARCHAR(50) = '1.1.123' ,@VersionStringB VARCHAR(50) = '1.1.123.123' ;
-- Declare @VersionStringA VARCHAR(50) = '1.1.123.123' ,@VersionStringB VARCHAR(50) = '1.1.123' ;
-- Declare @VersionStringA VARCHAR(50) = '1.1' ,@VersionStringB VARCHAR(50) = '1.1' ;
-- Declare @VersionStringA VARCHAR(50) = '1.2' ,@VersionStringB VARCHAR(50) = '1.1' ;
-- Declare @VersionStringA VARCHAR(50) = '1.1' ,@VersionStringB VARCHAR(50) = '1.2' ;
WITH
Indexes AS
(
SELECT 1 AS [Index]
, 'major' AS Name
UNION
SELECT 2
, 'minor'
UNION
SELECT 3
, 'build'
UNION
SELECT 4
, 'revision'
)
, SplitA AS
(
SELECT * FROM dbo.SplitStringToRows(@VersionStringA, '.')
)
, SplitB AS
(
SELECT * FROM dbo.SplitStringToRows(@VersionStringB, '.')
)
SELECT
CASE WHEN major = 0 THEN
CASE WHEN minor = 0 THEN
CASE WHEN build = 0 THEN
CASE WHEN revision = 0 THEN 0
ELSE revision END
ELSE build END
ELSE minor END
ELSE major END AS Compare
FROM
(
SELECT
MAX(CASE WHEN [Index] = 1 THEN Compare ELSE NULL END) AS major
,MAX(CASE WHEN [Index] = 2 THEN Compare ELSE NULL END) AS minor
,MAX(CASE WHEN [Index] = 3 THEN Compare ELSE NULL END) AS build
,MAX(CASE WHEN [Index] = 4 THEN Compare ELSE NULL END) AS revision
FROM(
SELECT [Index], Name,
CASE WHEN A = B THEN 0
WHEN A < B THEN -1
WHEN A > B THEN 1
END AS Compare
FROM
(
SELECT
i.[Index]
,i.Name
,ISNULL(a.Part, 0) AS A
,ISNULL(b.Part, 0) AS B
FROM Indexes i
LEFT JOIN SplitA a
ON a.[Index] = i.[Index]
LEFT JOIN SplitB b
ON b.[Index] = i.[Index]
) q1
) q2
) q3
)
GO
Ответ 13
Этот рекурсивный запрос преобразует любые номера разделенных номеров. в разделенные строки, оставляя каждый элемент до 10 символов, что позволяет сравнивать версии с номером или без номера сборки и размещения для нечисловых символов:
WITH cte (VersionNumber) AS (
SELECT '1.23.456' UNION ALL
SELECT '2.3' UNION ALL
SELECT '0.alpha-3'
),
parsed (VersionNumber, Padded) AS (
SELECT
CAST(SUBSTRING(VersionNumber, CHARINDEX('.', VersionNumber) + 1, LEN(VersionNumber)) + '.' AS NVARCHAR(MAX)),
CAST(RIGHT(REPLICATE('0', 10) + LEFT(VersionNumber, CHARINDEX('.', VersionNumber) - 1), 10) AS NVARCHAR(MAX))
FROM cte
UNION ALL
SELECT
SUBSTRING(VersionNumber, CHARINDEX('.', VersionNumber) + 1, LEN(VersionNumber)),
Padded + RIGHT(REPLICATE('0', 10) + LEFT(VersionNumber, CHARINDEX('.', VersionNumber) - 1), 10)
FROM parsed WHERE CHARINDEX('.', VersionNumber) > 0
)
SELECT Padded
FROM parsed
WHERE VersionNumber = ''
ORDER BY Padded;
Padded
------------------------------
0000000000000alpha-3
000000000100000000230000000456
00000000020000000003
