복붙노트

[SQL] "수"버전으로 SQL 정렬, 다양한 길이의 문자열

SQL

"수"버전으로 SQL 정렬, 다양한 길이의 문자열

나는 버전 번호 (예 : 1.1, 4.5.10, 등) 결과를 주문할 것이다 SQL 쿼리를 만들려고 해요

여기에 내가 뭘하려입니다 :

SELECT * FROM Requirements 
    WHERE Requirements.Release NOT LIKE '%Obsolete%' 
    ORDER BY Requirements.ReqNum

이제, ReqNum 필드는 문자열 필드이고 내가 162.1.11 같은 요구 사항 번호를 가지고 있기 때문에 불행히도 나는 그런 플로트 또는 뭔가 변경할 수 없습니다.

내가 다시 결과를 얻을 때, 나는 이런 순서를 얻을 것이다 :

1.1
1.10
1.11
1.3

어떻게 분류 사전 식 순서에 의한하는 쿼리를 작성할 수 있습니까?

... 나,

어떻게 데이터를 올바르게 정렬 할 수 있습니다?

사전에 입력 주셔서 감사합니다!

해결법

  1. ==============================

    1.MajorVersion, MinorVersion, 수정, 빌드 : 최상의 결과를 각 섹션은 그 자체가 열이 그래서 리팩토링 버전 번호 저장하십시오. 그 다음 순서의 문제는 갑자기 사소한된다. 또한 전체 문자열의 쉬운 검색을위한 계산 열을 구축 할 수 있습니다.

    MajorVersion, MinorVersion, 수정, 빌드 : 최상의 결과를 각 섹션은 그 자체가 열이 그래서 리팩토링 버전 번호 저장하십시오. 그 다음 순서의 문제는 갑자기 사소한된다. 또한 전체 문자열의 쉬운 검색을위한 계산 열을 구축 할 수 있습니다.

  2. ==============================

    2.PostgreSQL의에서 당신은 할 수 있습니다 :

    PostgreSQL의에서 당신은 할 수 있습니다 :

    SELECT * FROM Requirements
ORDER BY string_to_array(version, '.')::int[];

    이 마지막 :: INT는 []는 정수로 문자열 값을 변환하고 다음과 같은 비교합니다.

  3. ==============================

    3.

    SELECT * FROM Requirements 
WHERE Requirements.Release NOT LIKE '%Obsolete%' 
ORDER BY cast('/' + replace(Requirements.ReqNum , '.', '/') + '/' as hierarchyid);
  4. ==============================

    4.@ vuttipong-1의 대답에 약간의 변화 (T-SQL)

    @ vuttipong-1의 대답에 약간의 변화 (T-SQL)

    SELECT VersionNumber
FROM (
SELECT '6.1.3' VersionNumber UNION
SELECT '6.11.3' UNION
SELECT '6.2.3' UNION
SELECT '6.1.12' 
) AS q
ORDER BY cast('/' + VersionNumber + '/' as hierarchyid)

    우리가 슬래시로 교체 할 필요가 없습니다 2008로 시작하는 SQL Server의 작품, 점은 HIERARCHYID 컬럼의 문자열 표현에서 확인합니다. 해당 문서에서 인용 :

    버전 세그먼트가 제로로 시작해서는 안 :하지만 하나주의해야 할 점은있다.

  5. ==============================

    5.당신은 SQL 서버 땅에 있다면 ...

    당신은 SQL 서버 땅에 있다면 ...

    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 주소 및 버전 번호와 같은 다른 점 항목을 구문 분석하는 데 유용합니다. (당신은 점 표기법으로 항목을 변환) (REPLACE 사용할 수 있습니다 너무 ... 예를 들어, 1-2-3-4 -> 1.2.3.4)

  6. ==============================

    6.당신이하지 않으면 조엘 Coehoorn이 눈에 띌 수 있듯이 다음 그 종류 당신이 필요로, 예를 들어, 문자열로 다시 형식으로 버전 번호를 필요로 테이블을 재 설계

    당신이하지 않으면 조엘 Coehoorn이 눈에 띌 수 있듯이 다음 그 종류 당신이 필요로, 예를 들어, 문자열로 다시 형식으로 버전 번호를 필요로 테이블을 재 설계

    이것은 함수에 의해 수행하거나 DBMS이있는 경우 계산 된 / 가상 열을 사용 할 수있다. 그럼 당신은 ORDER BY 절에서 그 기능이나 열을 사용할 수 있습니다.

  7. ==============================

    7.다음 함수는 버전 번호를 가지고 3 자리로 각 레벨을 포맷합니다 :

    다음 함수는 버전 번호를 가지고 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
  8. ==============================

    8.다른 부분 BY CHARINDEX / SUBSTR와 ORDER : 당신은 문자열을 ( "."이미 구분 기호를 알고) 분할 할 수있다. 함수에서 작업을 수행 또는 일부에 의해 그것의 부분을 할.

    다른 부분 BY CHARINDEX / SUBSTR와 ORDER : 당신은 문자열을 ( "."이미 구분 기호를 알고) 분할 할 수있다. 함수에서 작업을 수행 또는 일부에 의해 그것의 부분을 할.

    그것은 꽤되지 않습니다 그것은 빠르지 않을 것입니다 : 당신이 빠른 쿼리를 필요로하는 경우 그래서, 토니 또는 조엘을 따르십시오.

  9. ==============================

    9.코드를 사용하지

    코드를 사용하지

    Insert into @table
Select 'A1' union all
Select 'A3' union all
Select 'A5' union all
Select 'A15' union all
Select 'A11' union all
Select 'A10' union all
Select 'A2' union all
Select 'B2' union all
Select 'C2' union all
Select 'C22' union all
Select 'C221' union all
Select 'A7' 

Select cod from @table
Order by LEN(cod),cod

    결과 :

    A1
A2
A3
A5
A7
B2
C2
A10
A11
A15
C22
C221

    그것은 간단합니다 :

    Declare @table table(id_ int identity(1,1), cod varchar(10))

Insert into @table
Select 'A1' union all
Select 'A3' union all
Select 'A5' union all
Select 'A15' union all
Select 'A11' union all
Select 'A10' union all
Select 'A2' union all
Select 'A7' 

Select cod from @table
Order by LEN(cod),cod
  10. ==============================

    10.PostgreSQL을, 그것은 더 쉬울 수 없었다 :

    PostgreSQL을, 그것은 더 쉬울 수 없었다 :

    (ver_no '.', '') string_to_array BY 버전 순서와 ver_no SELECT :: INT를 []

  11. ==============================

    11.이렇게하면 Microsoft SQL Server를 사용하는 경우 일 것입니다 :

    이렇게하면 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를 반환합니다. 당신이 2.1.2.3이 다음 약간의 논리를 변경해야하는 것보다 더 큰 것으로 9.0.1이 필요합니다. 내 예에서 9.0.1은 2.1.2.3 먼저 정렬됩니다.

  12. ==============================

    12.PostgreSQL를위한 기능

    PostgreSQL를위한 기능

    간단하게 사용

    select *
  from sample_table
 order by _sort_version(column_version);




CREATE FUNCTION _sort_version (
  p_version text
)
RETURNS text AS
$body$
declare 
  v_tab text[];
begin
  v_tab := string_to_array(p_version, '.');  

  for i in 1 .. array_length(v_tab, 1) loop
    v_tab[i] := lpad(v_tab[i], 4, '0');
  end loop;

  return array_to_string(v_tab, '.');
end;
$body$
LANGUAGE 'plpgsql'
VOLATILE
CALLED ON NULL INPUT
SECURITY DEFINER
COST 1;
  13. ==============================

    13.광산 등 A1, A2, A3, A10, A11, 같은 아파트 숫자 이었지만 나는 그들이 "권리"를 분류하고 싶다고, 같은 문제를 했어. 별도의 컬럼에 버전 번호까지 분할하지 작업을 수행하는 경우이 PL / SQL을 사용해보십시오. 그것은 A1과 같은 문자열을 사용하거나 잘 정렬되도록 A10and는 등 A0000001, A0000010로를 확장합니다. 그냥 같은, ORDER BY 절에이 전화

    광산 등 A1, A2, A3, A10, A11, 같은 아파트 숫자 이었지만 나는 그들이 "권리"를 분류하고 싶다고, 같은 문제를 했어. 별도의 컬럼에 버전 번호까지 분할하지 작업을 수행하는 경우이 PL / SQL을 사용해보십시오. 그것은 A1과 같은 문자열을 사용하거나 잘 정렬되도록 A10and는 등 A0000001, A0000010로를 확장합니다. 그냥 같은, ORDER BY 절에이 전화

    선택 apt_num 아파트에서 PAD에 의한 위해 (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;
  14. ==============================

    14.여기에 문자열을 추출하는 예제 쿼리입니다. 당신은-그대로, 또는 단순히 쿼리에 하나의 데이터베이스의 리팩토링 업데이트를이 사용할 수 있어야합니다. 그러나, 나는 그 시간에 얼마나 확실하지 않다; 조심하고 테스트하기 위해 뭔가.

    여기에 문자열을 추출하는 예제 쿼리입니다. 당신은-그대로, 또는 단순히 쿼리에 하나의 데이터베이스의 리팩토링 업데이트를이 사용할 수 있어야합니다. 그러나, 나는 그 시간에 얼마나 확실하지 않다; 조심하고 테스트하기 위해 뭔가.

    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
  15. ==============================

    15.높은 성능이 문제가되는 경우 확인, 당신의 유일한 옵션은 뭔가 숫자로 값을 변경하는 것입니다.

    높은 성능이 문제가되는 경우 확인, 당신의 유일한 옵션은 뭔가 숫자로 값을 변경하는 것입니다.

    이 낮은 사용 쿼리의 경우 그러나, 당신은 단지 그하여 숫자와 순서를 분할 할 수 있습니다.

    이 쿼리는 메이저와 마이너 버전 번호를 가정하고 그들은 단지 숫자를 포함하는 것이다.

    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 )))
  16. ==============================

    16.오라클 가정 올인원 쿼리 순수 주의자, 들어, 일부 INSTR / SUBSTR / 디코딩 / TO_NUMBER 부두를 해결할 수 있습니다 :

    오라클 가정 올인원 쿼리 순수 주의자, 들어, 일부 INSTR / SUBSTR / 디코딩 / 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
          ) 
      )
    )
;

    I는 다음과 같은주의 사항이 많이있다 생각한다 :

  17. ==============================

    17.여기서 숫자 시퀀스 숫자 대비되도록, 임의의 문자열을 비교한다 PostgreSQL를위한 비교 함수이다. 즉, "ABC123"> "ABC2"하지만, "AB123"< "ABC2". 그것은 일반적으로 수행 등의 비교 함수는 -1, 0, +1 반환합니다.

    여기서 숫자 시퀀스 숫자 대비되도록, 임의의 문자열을 비교한다 PostgreSQL를위한 비교 함수이다. 즉, "ABC123"> "ABC2"하지만, "AB123"< "ABC2". 그것은 일반적으로 수행 등의 비교 함수는 -1, 0, +1 반환합니다.

    CREATE FUNCTION vercmp(a text, b text) RETURNS integer AS $$
DECLARE
   ar text[];
   br text[];
   n integer := 1;
BEGIN
   SELECT array_agg(y) INTO ar FROM (SELECT array_to_string(regexp_matches(a, E'\\d+|\\D+|^$', 'g'),'') y) x;
   SELECT array_agg(y) INTO br FROM (SELECT array_to_string(regexp_matches(b, E'\\d+|\\D+|^$', 'g'),'') y) x;
   WHILE n <= array_length(ar, 1) AND n <= array_length(br, 1) LOOP
      IF ar[n] ~ E'^\\d+$' AND br[n] ~ E'^\\d+$' THEN
         IF ar[n]::integer < br[n]::integer THEN
            RETURN -1;
         ELSIF ar[n]::integer > br[n]::integer THEN
            RETURN 1;
         END IF;
      ELSE
         IF ar[n] < br[n] THEN
            RETURN -1;
         ELSIF ar[n] > br[n] THEN
            RETURN 1;
         END IF;
      END IF;
      n := n + 1;
   END LOOP;

   IF n > array_length(ar, 1) AND n > array_length(br, 1) THEN
      RETURN 0;
   ELSIF n > array_length(ar, 1) THEN
      RETURN 1;
   ELSE
      RETURN -1;
   END IF;
END;
$$ IMMUTABLE LANGUAGE plpgsql;

    이 분류는 <#을 사용 필드에 의해 ORDER와 비교 함수를 사용하여 수행 할 수 있도록 다음 연산자 클래스를 생성 할 수 있습니다 :

    CREATE OR REPLACE FUNCTION vernum_lt(a text, b text) RETURNS boolean AS $$
BEGIN
   RETURN vercmp(a, b) < 0;
END;
$$ IMMUTABLE LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION vernum_lte(a text, b text) RETURNS boolean AS $$
BEGIN
   RETURN vercmp(a, b) <= 0;
END;
$$ IMMUTABLE LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION vernum_eq(a text, b text) RETURNS boolean AS $$
BEGIN
   RETURN vercmp(a, b) = 0;
END;
$$ IMMUTABLE LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION vernum_gt(a text, b text) RETURNS boolean AS $$
BEGIN
   RETURN vercmp(a, b) > 0;
END;
$$ IMMUTABLE LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION vernum_gte(a text, b text) RETURNS boolean AS $$
BEGIN
   RETURN vercmp(a, b) >= 0;
END;
$$ IMMUTABLE LANGUAGE plpgsql;

CREATE OPERATOR <# ( PROCEDURE = vernum_lt, LEFTARG = text, RIGHTARG = text);
CREATE OPERATOR ># ( PROCEDURE = vernum_gt, LEFTARG = text, RIGHTARG = text);
CREATE OPERATOR =# ( PROCEDURE = vernum_lte, LEFTARG = text, RIGHTARG = text);
CREATE OPERATOR <=# ( PROCEDURE = vernum_lte, LEFTARG = text, RIGHTARG = text);
CREATE OPERATOR >=# ( PROCEDURE = vernum_gte, LEFTARG = text, RIGHTARG = text);

CREATE OPERATOR CLASS vernum_ops FOR TYPE varchar USING btree AS
  OPERATOR 1 <# (text, text),
  OPERATOR 2 <=# (text, text),
  OPERATOR 3 =#(text, text),
  OPERATOR 4 >=# (text, text),
  OPERATOR 5 ># (text, text),
  FUNCTION 1 vercmp(text, text)
;
  18. ==============================

    18.이 방법을 수정했습니다.

    이 방법을 수정했습니다.

    <pre>
00000001    1
00000001.00000001   1.1
00000001.00000001.00000001  1.1.1
00000001.00000002   1.2
00000001.00000009   1.9
00000001.00000010   1.10
00000001.00000011   1.11
00000001.00000012   1.12
00000002    2
00000002.00000001   2.1
00000002.00000001.00000001  2.1.1
00000002.00000002   2.2
00000002.00000009   2.9
00000002.00000010   2.10
00000002.00000011   2.11
00000002.00000012   2.12

select * from (select '000000001' as tCode,'1' as Code union
select '000000001.000000001' as tCode,'1.1'as Code union
select '000000001.000000001.000000001' as tCode,'1.1.1'as Code union
select '000000001.000000002' as tCode,'1.2'  union
select '000000001.000000010' as tCode,'1.10'as Code union
select '000000001.000000011' as tCode,'1.11'as Code union
select '000000001.000000012' as tCode,'1.12'as Code union
select '000000001.000000009' as tCode,'1.9' as Code
union
select '00000002' as tCode,'2'as Code union
select '00000002.00000001' as tCode,'2.1'as Code union
select '00000002.00000001.00000001' as tCode,'2.1.1'as Code union
select '00000002.00000002' as tCode,'2.2'as Code union
select '00000002.00000010' as tCode,'2.10'as Code union
select '00000002.00000011' as tCode,'2.11'as Code union
select '00000002.00000012' as tCode,'2.12'as Code union
select '00000002.00000009' as tCode,'2.9'as Code ) as t
order by t.tCode

</pre>

<pre>


public static string GenerateToCodeOrder(this string code)
    {
        var splits = code.Split('.');
        var codes = new List<string>();
        foreach (var str in splits)
        {
            var newStr = "";
            var zeroLength = 10 - str.Length;
            for (int i = 1; i < zeroLength; i++)
            {
                newStr += "0";
            }
            newStr += str;
            codes.Add(newStr);
        }
        return string.Join(".", codes);
    }

</pre>
  19. ==============================

    19.MYSQL에서 나는 몇 가지 데이터 HIERARCHYID에 문제가 있었다 ...

    MYSQL에서 나는 몇 가지 데이터 HIERARCHYID에 문제가 있었다 ...

    select Convert(hierarchyid, '/' + '8.3.0000.1088' + '/')

    (에 의존 '.'분리되는)이 내가 사용 pasename를 해결하기 위해 ...

    Order by
convert(int, reverse (Parsename( reverse(tblSoftware.softwareVersion) , 1))),
convert(int, reverse (Parsename( reverse(tblSoftware.softwareVersion) , 2))),
convert(int, reverse (Parsename( reverse(tblSoftware.softwareVersion) , 3))),
convert(int, reverse (Parsename( reverse(tblSoftware.softwareVersion) , 4))),
convert(int, reverse (Parsename( reverse(tblSoftware.softwareVersion) , 5)))
  20. ==============================

    20.버전의 열 유형이 VARCHAR 인 경우 예상대로 정렬이 수행된다. VARCHAR는 공백으로 채워되지 beacuse이다.

    버전의 열 유형이 VARCHAR 인 경우 예상대로 정렬이 수행된다. VARCHAR는 공백으로 채워되지 beacuse이다.

  21. ==============================

    21.조엘 Coehoorn 말했듯이 나는 할 것이다. 그런 다음에 수동으로 할 필요가 없습니다 데이터 구조를 재 배열합니다. 당신은 모든 600 개의 기록을 위해 일을 할 것입니다 간단한 스크립트를 작성할 수 있습니다.

    조엘 Coehoorn 말했듯이 나는 할 것이다. 그런 다음에 수동으로 할 필요가 없습니다 데이터 구조를 재 배열합니다. 당신은 모든 600 개의 기록을 위해 일을 할 것입니다 간단한 스크립트를 작성할 수 있습니다.

  22. ==============================

    22.그냥 (인라인, 빈 문자열로 교체)이 결과에 의해 INT 순서로 결과를 캐스팅 점을 제거합니다. 좋은 작품 :

    그냥 (인라인, 빈 문자열로 교체)이 결과에 의해 INT 순서로 결과를 캐스팅 점을 제거합니다. 좋은 작품 :

    a.Version = 1.4.18.14

select...
Order by cast( replace (a.Version,'.','') as int)

    23. from https://stackoverflow.com/questions/528830/sql-sort-by-version-number-a-string-of-varying-length by cc-by-sa and MIT license

'SQL' 카테고리의 다른 글

[SQL] 같은 '%'NULL 값을 허용하지 않습니다  (0) 2020.06.06
[SQL] VARCHAR를 값을 변환 할 때 변환 int 데이터 형식 '단순한'를 실패한  (0) 2020.06.06
[SQL] MySQL은 SELECT는 NOT IN이 (SELECT가 B의 X) WHERE A로부터 X - 예기치 않은 결과를  (0) 2020.06.06
[SQL] SQLite는 외국인 키 제약 조건을 활성화  (0) 2020.06.06
[SQL] 문자열 PHP에서 두 문자 사이의 문자열을 추출  (0) 2020.06.06
,

티스토리툴바