Вид SQL версией “число”, строка переменной длины

Я сделал бы, как сказал Joel Coehoorn. Затем для перестраивания структуры данных Вы не должны вручную делать этого. Можно записать простой сценарий, который сделает задание для всех 600 записей.

Для all-in-one-query пуристов, принимая Oracle, некоторый instr/substr/decode/to_number вуду может решить его:

SELECT *
FROM Requirements
WHERE Release NOT LIKE '%Obsolete%'
ORDER BY
    to_number(
      substr( reqnum, 1, instr( reqnum, '.' ) - 1 )
    )
  , to_number(
      substr( 
          reqnum
        , instr( reqnum, '.' ) + 1 -- start: after first occurance
        , decode( 
              instr( reqnum, '.', 1, 2 )
            , 0, length( reqnum )
            , instr( reqnum, '.', 1, 2 ) - 1 
          ) -- second occurance (or end)
          - instr( reqnum, '.', 1, 1) -- length: second occurance (or end) less first
      )
    )
  , to_number(
      decode( 
          instr( reqnum, '.', 1, 2 )
        , 0, null
        , substr( 
              reqnum
            , instr( reqnum, '.', 1, 2 ) + 1 -- start: after second occurance
            , decode( 
                  instr( reqnum, '.', 1, 3 )
                , 0, length( reqnum )
                , instr( reqnum, '.', 1, 3 ) - 1 
              ) -- third occurance (or end)
              - instr( reqnum, '.', 1, 2) -- length: third occurance (or end) less second
          ) 
      )
    )
  , to_number(
      decode( 
          instr( reqnum, '.', 1, 3 )
        , 0, null
        , substr( 
              reqnum
            , instr( reqnum, '.', 1, 3 ) + 1 -- start: after second occurance
            , decode( 
                  instr( reqnum, '.', 1, 4 )
                , 0, length( reqnum )
                , instr( reqnum, '.', 1, 4 ) - 1 
              ) -- fourth occurance (or end)
              - instr( reqnum, '.', 1, 3) -- length: fourth occurance (or end) less third
          ) 
      )
    )
;

я подозреваю, что существует много протестов включая:

• предположение о присутствии вспомогательной версии (второй)
• ограниченный четырьмя версиями, как указано в комментариях вопроса

Хорошо, если высокая производительность является проблемой затем, Ваша единственная опция состоит в том, чтобы изменить Ваши значения во что-то числовое.

Однако, если это - низкий запрос использования затем, можно просто разделить числа и порядок теми.

Этот запрос принимает просто номера основной версии и номера вспомогательной версии и что они содержат просто числа.

SELECT
    *
FROM
    Requirements
WHERE
    Requirements.Release NOT LIKE '%Obsolete%'
ORDER BY
    CONVERT(int, RIGHT(REPLICATE('0', 10) + LEFT(Requirements.ReqNum, CHARINDEX('.', Requirements.ReqNum)-1), 10)),
    CONVERT(int, SUBSTRING(Requirements.ReqNum, CHARINDEX('.', Requirements.ReqNum )+1, LEN(Requirements.ReqNum) - CHARINDEX('.', Requirements.ReqNum )))

Вот запрос в качестве примера, который извлекает строку. Необходимо смочь использовать это или в рефакторинге ОБНОВЛЕНИЯ базы данных, или в просто в запросе как есть. Однако я не уверен, как это вовремя; просто что-то, чтобы предостеречься и протестировать на.

SELECT SUBSTRING_INDEX("1.5.32",'.',1) AS MajorVersion,
  SUBSTRING_INDEX(SUBSTRING_INDEX("1.5.32",'.',-2),'.',1) AS MinorVersion,
  SUBSTRING_INDEX("1.5.32",'.',-1) AS Revision;

это возвратится:

MajorVersion | MinorVersion | Revision
1            | 5            | 32

У меня была та же проблема, хотя мой был с числами квартиры как A1, A2, A3, A10, A11, и т.д., что они хотели отсортировать "право". Если разделение номера версии в отдельные столбцы не работает, пробует это МН / SQL. Это берет строку как A1, или A10and разворачивает его в A0000001, A0000010, и т.д., таким образом, это сортирует приятно. Просто назовите это В пункте ORDER BY, как

выбор apt_num от порядка квартиры КЛАВИАТУРОЙ (apt_num)

function pad(inString IN VARCHAR2)
   return VARCHAR2

--This function pads the numbers in a alphanumeric string.
--It is particularly useful in sorting, things like "A1, A2, A10"
--which would sort like "A1, A10, A2" in a standard "ORDER BY name" clause
--but by calling "ORDER BY pkg_sort.pad(name)" it will sort as "A1, A2, A10" because this
--function will convert it to "A00000000000000000001, A00000000000000000002, A00000000000000000010" 
--(but since this is in the order by clause, it will
--not be displayed.

--currently, the charTemplate variable pads the number to 20 digits, so anything up to 99999999999999999999 
--will work correctly.
--to increase the size, just change the charTemplate variable.  If the number is larger than 20 digits, it will just
--appear without padding.


   is
      outString VARCHAR2(255);
      numBeginIndex NUMBER;
      numLength NUMBER;
      stringLength NUMBER;
      i NUMBER;
      thisChar VARCHAR2(6);
      charTemplate VARCHAR2(20) := '00000000000000000000';
      charTemplateLength NUMBER := 20;


   BEGIN
      outString := null;
      numBeginIndex := -1;
      numLength := 0;
      stringLength := length(inString);

      --loop through each character, get that character
      FOR i IN 1..(stringLength) LOOP
         thisChar := substr(inString, i, 1);

         --if this character is a number
         IF (FcnIsNumber(thisChar)) THEN

            --if we haven't started a number yet
            IF (numBeginIndex = -1) THEN
               numBeginIndex := i;
               numLength := 1;

            --else if we're in a number, increase the length
            ELSE 
               numLength := numLength + 1;
            END IF;

            --if this is the last character, we have to append the number
            IF (i = stringLength) THEN
               outString:= FcnConcatNumber(inString, outString, numBeginIndex, numLength, charTemplate, charTemplateLength);
            END IF;

         --else this is a character
         ELSE

            --if we were previously in a number, concat that and reset the numBeginIndex
            IF (numBeginIndex != -1) THEN
               outString:= FcnConcatNumber(inString, outString, numBeginIndex, numLength, charTemplate, charTemplateLength);
               numBeginIndex := -1;
               numLength := 0;
            END IF;

            --concat the character
            outString := outString || thisChar;
         END IF;
      END LOOP;

      RETURN outString;

   --any exception, just return the original string
   EXCEPTION WHEN OTHERS THEN
      RETURN inString;

   END;     

Это работало бы при использовании Microsoft SQL Server:

create function fnGetVersion (@v AS varchar(50)) returns bigint as
begin
declare @n as bigint;
declare @i as int;
select @n = 0;
select @i = charindex('.',@v);
while(@i > 0)
begin
    select @n = @n * 1000;
    select @n = @n + cast(substring(@v,1,@i-1) as bigint); 
    select @v = substring(@v,@i+1,len(@v)-@i);
    select @i = charindex('.',@v);
end
return @n * 1000 + cast(@v as bigint);
end

Тест путем выполнения этой команды:

select dbo.fnGetVersion('1.2.3.4')

, Который возвратил бы номер 1002003004, который является совершенно поддающимся сортировке. Вы, нуждаются 9.0.1, чтобы быть больше, чем 2.1.2.3 затем, необходимо ли было бы изменить логику немного. В моем примере 9.0.1 был бы отсортирован прежде 2.1.2.3.

Вы могли разделить строку (Вы уже знаете разделители:".") с CHARINDEX / SUBSTR и ORDER BY различные части. Сделайте это в функции или сделайте это часть частью.

Это не будет симпатично, и это не будет быстро: таким образом, если Вы нуждаетесь в быстрых запросах, следуете за Tony или Joel.

Следующая функция возьмет номер версии и формат, который каждый выравнивает к 3 цифрам:

Использование:

select * from TableX order by dbo.fn_VersionPad(VersionCol1)

Функция:

CREATE FUNCTION [dbo].[fn_VersionPad]
(
    @version varchar(20)
)
RETURNS varchar(20)
AS
BEGIN
    /*
        Purpose:  Pads multi-level Version Number sections to 3 digits
        Example:  1.2.3.4
        Returns:  001.002.003.004
    */

    declare @verPad varchar(20)
    declare @i int
    declare @digits int

    set @verPad = ''

    set @i = len(@version)
    set @digits = 0

    while @i > 0
    begin
        if (substring(@version, @i, 1) = '.')
        begin
            while (@digits < 3)
            begin
                -- Pad version level to 3 digits
                set @verPad = '0' + @verPad
                set @digits = @digits + 1
            end

            set @digits = -1
        end

        set @verPad = substring(@version, @i, 1) + @verPad

        set @i = @i - 1
        set @digits = @digits + 1
    end

    while (@digits < 3)
    begin
        -- Pad version level to 3 digits
        set @verPad = '0' + @verPad
        set @digits = @digits + 1
    end

    return @verPad
END

Если Вы не перепроектируете таблицу, как Joel Coehoorn разумно предполагает, то необходимо переформатировать номера версий к строке, что виды, как Вы требуете, например,

• 1.1-> 0001.0001.0000
• 162.1.11-> 0162.0001.0011

, Это могло быть сделано функцией или использованием вычисленного/виртуального столбца, если Ваш DBMS имеет их. Затем можно использовать ту функцию или столбец в пункте ORDER BY.

Если Вы находитесь на земле SQL Server...

DECLARE @string varchar(40)
SET @string = '1.2.3.4'
SELECT PARSENAME(@string, 1), PARSENAME(@string, 2), PARSENAME(@string, 3), PARSENAME(@string, 4)

Результаты: 4, 3, 2, 1

Полезный для парсинга IP-адресов и других точечных объектов, таких как номер версии. (Можно использовать ЗАМЕНУ () для преобразования объектов в точечную нотацию также..., например, 1-2-3-4-> 1.2.3.4)