SQL Server : 모든 대문자를 적절한 대소 문자 / 제목 대소 문자로 설정

모두 대문자로 가져온 테이블이 있는데 적절한 케이스로 바꾸고 싶습니다. 이 작업을 완료하는 데 사용한 스크립트는 무엇입니까?

트릭을 수행 할 UDF가 있습니다.

create function ProperCase(@Text as varchar(8000))
returns varchar(8000)
as
begin
  declare @Reset bit;
  declare @Ret varchar(8000);
  declare @i int;
  declare @c char(1);

  if @Text is null
    return null;

  select @Reset = 1, @i = 1, @Ret = '';

  while (@i <= len(@Text))
    select @c = substring(@Text, @i, 1),
      @Ret = @Ret + case when @Reset = 1 then UPPER(@c) else LOWER(@c) end,
      @Reset = case when @c like '[a-zA-Z]' then 0 else 1 end,
      @i = @i + 1
  return @Ret
end

그래도 데이터를 업데이트하는 데 사용해야합니다.

이 기능 :

• 공백으로 구분 된 모든 "UPPER CASE"단어 "적절한 대소 문자"
• "소문자 단어"만 남겨 둡니다.
• 영어가 아닌 알파벳에서도 제대로 작동합니다.
• 최신 SQL 서버 버전의 멋진 기능을 사용하지 않는다는 점에서 이식성이 있습니다.
• 유니 코드 지원을 위해 NCHAR 및 NVARCHAR을 사용하도록 쉽게 변경할 수있을뿐만 아니라 적합한 매개 변수 길이도 사용할 수 있습니다.
• 공백 정의를 구성 할 수 있습니다.

CREATE FUNCTION ToProperCase(@string VARCHAR(255)) RETURNS VARCHAR(255)
AS
BEGIN
  DECLARE @i INT           -- index
  DECLARE @l INT           -- input length
  DECLARE @c NCHAR(1)      -- current char
  DECLARE @f INT           -- first letter flag (1/0)
  DECLARE @o VARCHAR(255)  -- output string
  DECLARE @w VARCHAR(10)   -- characters considered as white space

  SET @w = '[' + CHAR(13) + CHAR(10) + CHAR(9) + CHAR(160) + ' ' + ']'
  SET @i = 1
  SET @l = LEN(@string)
  SET @f = 1
  SET @o = ''

  WHILE @i <= @l
  BEGIN
    SET @c = SUBSTRING(@string, @i, 1)
    IF @f = 1 
    BEGIN
     SET @o = @o + @c
     SET @f = 0
    END
    ELSE
    BEGIN
     SET @o = @o + LOWER(@c)
    END

    IF @c LIKE @w SET @f = 1

    SET @i = @i + 1
  END

  RETURN @o
END

결과:

dbo.ToProperCase('ALL UPPER CASE and    SOME lower ÄÄ ÖÖ ÜÜ ÉÉ ØØ ĈĈ ÆÆ')
-----------------------------------------------------------------
All Upper Case and      Some lower Ää Öö Üü Éé Øø Cc Ææ

UPDATE titles
  SET title =
      UPPER(LEFT(title, 1)) +
        LOWER(RIGHT(title, LEN(title) - 1))

http://sqlmag.com/t-sql/how-title-case-column-value

SQL Server에서 CLR을 활성화 할 수있는 경우 (2005 이상 필요) TextInfo.ToTitleCase 기본 제공 함수 를 사용 하는 CLR 함수 를 만들 수 있습니다.이 함수 를 사용하면 몇 번만 문화 인식 방식으로이를 수행 할 수 있습니다. 코드 줄.

나는 이것이이 스레드의 늦은 게시물이라는 것을 알고 있지만 볼 가치가 있습니다. 이 기능은 항상 나를 위해 작동합니다. 그래서 그것을 공유하는 것을 생각했습니다.

CREATE FUNCTION [dbo].[fnConvert_TitleCase] (@InputString VARCHAR(4000) )
RETURNS VARCHAR(4000)
AS
BEGIN
DECLARE @Index INT
DECLARE @Char CHAR(1)
DECLARE @OutputString VARCHAR(255)

SET @OutputString = LOWER(@InputString)
SET @Index = 2
SET @OutputString = STUFF(@OutputString, 1, 1,UPPER(SUBSTRING(@InputString,1,1)))

WHILE @Index <= LEN(@InputString)
BEGIN
    SET @Char = SUBSTRING(@InputString, @Index, 1)
    IF @Char IN (' ', ';', ':', '!', '?', ',', '.', '_', '-', '/', '&','''','(')
    IF @Index + 1 <= LEN(@InputString)
BEGIN
    IF @Char != ''''
    OR
    UPPER(SUBSTRING(@InputString, @Index + 1, 1)) != 'S'
    SET @OutputString =
    STUFF(@OutputString, @Index + 1, 1,UPPER(SUBSTRING(@InputString, @Index + 1, 1)))
END
    SET @Index = @Index + 1
END

RETURN ISNULL(@OutputString,'')
END

테스트 호출 :

select dbo.fnConvert_TitleCase(Upper('ÄÄ ÖÖ ÜÜ ÉÉ ØØ ĈĈ ÆÆ')) as test
select dbo.fnConvert_TitleCase(upper('Whatever the mind of man can conceive and believe, it can achieve. – Napoleon hill')) as test

결과 :

나는 게임에 조금 늦었지만 이것이 더 기능적이며 러시아어, 독일어, 태국어, 베트남어 등 모든 언어에서 작동한다고 생각합니다. '또는-또는. 또는 (또는) 또는 공백 (분명히 :).

CREATE FUNCTION [dbo].[fnToProperCase]( @name nvarchar(500) )
RETURNS nvarchar(500)
AS
BEGIN
declare @pos    int = 1
      , @pos2   int

if (@name <> '')--or @name = lower(@name) collate SQL_Latin1_General_CP1_CS_AS or @name = upper(@name) collate SQL_Latin1_General_CP1_CS_AS)
begin
    set @name = lower(rtrim(@name))
    while (1 = 1)
    begin
        set @name = stuff(@name, @pos, 1, upper(substring(@name, @pos, 1)))
        set @pos2 = patindex('%[- ''.)(]%', substring(@name, @pos, 500))
        set @pos += @pos2
        if (isnull(@pos2, 0) = 0 or @pos > len(@name))
            break
    end
end

return @name
END
GO

대소 문자가 혼합 된 데이터를 가져 오는 SSIS에서 적절한 대소 문자가있는 열에 대한 조회를 수행해야하는 경우 원본이 혼합되고 조회 원본이 적절한 경우 조회가 실패 함을 알 수 있습니다. 또한 파생 열에 대한 SQL Server 2008r2 용 SSIS는 오른쪽 및 왼쪽 함수를 사용할 수 없습니다. 저에게 적합한 솔루션은 다음과 같습니다.

UPPER(substring(input_column_name,1,1)) + LOWER(substring(input_column_name, 2, len(input_column_name)-1))

다음은 루프가 아닌 시퀀스 또는 숫자 테이블을 사용하는 버전입니다. WHERE 절을 수정하여 문자를 대문자로 변환 할시기에 대한 개인 규칙을 적용 할 수 있습니다. 아포스트로피를 제외하고 문자가 아닌 문자로 진행되는 모든 문자를 대문자로 표시하는 간단한 집합을 포함했습니다. 이것은 "3"이 문자가 아니기 때문에 123apple이 "a"와 일치한다는 것을 의미합니다. 공백 (공백, 탭, 캐리지 리턴, 줄 바꿈) 만 원하는 경우 패턴 '[^a-z]'을 '[' + Char(32) + Char(9) + Char(13) + Char(10) + ']'.

CREATE FUNCTION String.InitCap( @string nvarchar(4000) ) RETURNS nvarchar(4000) AS
BEGIN

-- 1. Convert all letters to lower case
    DECLARE @InitCap nvarchar(4000); SET @InitCap = Lower(@string);

-- 2. Using a Sequence, replace the letters that should be upper case with their upper case version
    SELECT @InitCap = Stuff( @InitCap, n, 1, Upper( SubString( @InitCap, n, 1 ) ) )
    FROM (
        SELECT (1 + n1.n + n10.n + n100.n + n1000.n) AS n
        FROM       (SELECT 0 AS n UNION SELECT    1 UNION SELECT    2 UNION SELECT    3 UNION SELECT    4 UNION SELECT    5 UNION SELECT    6 UNION SELECT    7 UNION SELECT    8 UNION SELECT    9) AS    n1
        CROSS JOIN (SELECT 0 AS n UNION SELECT   10 UNION SELECT   20 UNION SELECT   30 UNION SELECT   40 UNION SELECT   50 UNION SELECT   60 UNION SELECT   70 UNION SELECT   80 UNION SELECT   90) AS   n10
        CROSS JOIN (SELECT 0 AS n UNION SELECT  100 UNION SELECT  200 UNION SELECT  300 UNION SELECT  400 UNION SELECT  500 UNION SELECT  600 UNION SELECT  700 UNION SELECT  800 UNION SELECT  900) AS  n100
        CROSS JOIN (SELECT 0 AS n UNION SELECT 1000 UNION SELECT 2000 UNION SELECT 3000)                                                                                                             AS n1000
        ) AS Sequence
    WHERE 
        n BETWEEN 1 AND Len( @InitCap )
    AND SubString( @InitCap, n, 1 ) LIKE '[a-z]'                 /* this character is a letter */
    AND (
        n = 1                                                    /* this character is the first `character` */
        OR SubString( @InitCap, n-1, 1 ) LIKE '[^a-z]'           /* the previous character is NOT a letter */
        )
    AND (
        n < 3                                                    /* only test the 3rd or greater characters for this exception */
        OR SubString( @InitCap, n-2, 3 ) NOT LIKE '[a-z]''[a-z]' /* exception: The pattern <letter>'<letter> should not capatolize the letter following the apostrophy */
        )

-- 3. Return the modified version of the input
    RETURN @InitCap

END

위에 게시 한 링크는 주요 문제를 해결하는 훌륭한 옵션입니다. 적어도 모든 경우 (Smith-Jones, von Haussen, John Smith MD)를 프로그래밍 방식으로 설명 할 수는 없습니다. 적어도 우아한 방식은 아닙니다. Tony는 이러한 경우를 처리하기 위해 예외 / 중단 문자의 개념을 소개합니다. 어쨌든, Cervo의 아이디어 (위의 모든 낮은 문자 앞에 공백이 있음)를 기반으로 replace 문을 대신 단일 테이블 기반 replace로 래핑 할 수 있습니다. 실제로 모든 낮은 / 위 문자 조합을 @alpha에 삽입 할 수 있으며 문은 변경되지 않습니다.

declare @str    nvarchar(8000)
declare @alpha  table (low nchar(1), up nchar(1))


set @str = 'ALL UPPER CASE and    SOME lower ÄÄ ÖÖ ÜÜ ÉÉ ØØ ĈĈ ÆÆ'

-- stage the alpha (needs number table)
insert into @alpha
    -- A-Z / a-z
    select      nchar(n+32),
                nchar(n)
    from        dbo.Number
    where       n between 65 and 90 or
                n between 192 and 223

-- append space at start of str
set @str = lower(' ' + @str)

-- upper all lower case chars preceded by space
select  @str = replace(@str, ' ' + low, ' ' + up) 
from    @Alpha

select @str

The von Neumann 's, McCain 's, DeGuzman 's 및 Johnson-Smith 's를 처리하기 위해 예외 조회를 유지하는 것이 좋습니다.

@Richard Sayakanit 답변에서 빌리고 개선되었습니다. 이것은 여러 단어를 처리합니다. 그의 대답과 마찬가지로 이것은 UDF를 사용하지 않고 내장 함수 ( STRING_SPLIT및 STRING_AGG) 만 사용하며 매우 빠릅니다. STRING_AGGSQL Server 2017이 필요하지만 항상 STUFF/XML트릭을 사용할 수 있습니다 . 모든 예외를 처리하지는 않지만 많은 요구 사항에 적합합니다.

SELECT StateName = 'North Carolina' 
INTO #States
UNION ALL
SELECT 'Texas'


;WITH cteData AS 
(
    SELECT 
        UPPER(LEFT(value, 1)) +
            LOWER(RIGHT(value, LEN(value) - 1)) value, op.StateName
    FROM   #States op
    CROSS APPLY STRING_SPLIT(op.StateName, ' ') AS ss
)
SELECT 
    STRING_AGG(value, ' ')
FROM cteData c 
GROUP BY StateName

@Galwegian의 답변에 대한 약간의 수정-예를 St Elizabeth's들어 St Elizabeth'S.

이 수정은 아포스트로피 -s를 소문자로 유지합니다. 여기서 s는 제공된 문자열의 끝에 오거나 s 뒤에 공백이옵니다 (이러한 상황에서만).

create function properCase(@text as varchar(8000))
returns varchar(8000)
as
begin
    declare @reset int;
    declare @ret varchar(8000);
    declare @i int;
    declare @c char(1);
    declare @d char(1);

    if @text is null
    return null;

    select @reset = 1, @i = 1, @ret = '';

    while (@i <= len(@text))
    select
        @c = substring(@text, @i, 1),
        @d = substring(@text, @i+1, 1),
        @ret = @ret + case when @reset = 1 or (@reset=-1 and @c!='s') or (@reset=-1 and @c='s' and @d!=' ') then upper(@c) else lower(@c) end,
        @reset = case when @c like '[a-za-z]' then 0 when @c='''' then -1 else 1 end,
        @i = @i + 1
    return @ret
end

돌아서 다:

• st elizabeth's 으로 St Elizabeth's
• o'keefe 으로 O'Keefe
• o'sullivan 으로 O'Sullivan

영어가 아닌 입력에 대해 다른 솔루션이 선호된다는 다른 사람들의 의견은 여전히 ​​남아 있습니다.

다음이 더 효율적이라는 것을 알게 될 것입니다.

IF OBJECT_ID('dbo.ProperCase') IS NOT NULL
    DROP FUNCTION dbo.ProperCase
GO
CREATE FUNCTION dbo.PROPERCASE (
    @str VARCHAR(8000))
RETURNS VARCHAR(8000)
AS
BEGIN
    SET @str = ' ' + @str
    SET @str = REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE( @str, ' a', ' A'), ' b', ' B'), ' c', ' C'), ' d', ' D'), ' e', ' E'), ' f', ' F'), ' g', ' G'), ' h', ' H'), ' i', ' I'), ' j', ' J'), ' k', ' K'), ' l', ' L'), ' m', ' M'), ' n', ' N'), ' o', ' O'), ' p', ' P'), ' q', ' Q'), ' r', ' R'), ' s', ' S'), ' t', ' T'), ' u', ' U'), ' v', ' V'), ' w', ' W'), ' x', ' X'), ' y', ' Y'), ' z', ' Z')
    RETURN RIGHT(@str, LEN(@str) - 1)
END
GO

replace 문을 잘라내어 SQL 쿼리에 직접 붙여 넣을 수 있습니다. 매우 추악하지만 @str을 관심있는 열로 대체하면 이렇게 게시 된 udfs와 같이 암시 적 커서에 대한 대가를 지불하지 않을 것입니다. 내 UDF를 사용하는 것이 훨씬 더 효율적이라는 것을 알았습니다.

아 그리고 수동으로 replace 문을 생성하는 대신 다음을 사용하십시오.

-- Code Generator for expression
DECLARE @x  INT,
    @c  CHAR(1),
    @sql    VARCHAR(8000)
SET @x = 0
SET @sql = '@str' -- actual variable/column you want to replace
WHILE @x < 26
BEGIN
    SET @c = CHAR(ASCII('a') + @x)
    SET @sql = 'REPLACE(' + @sql + ', '' ' + @c+  ''', '' ' + UPPER(@c) + ''')'
    SET @x = @x + 1
END
PRINT @sql

어쨌든 행 수에 따라 다릅니다. s / \ b ([az]) / uc $ 1 / 만 할 수 있으면 좋겠지 만, 우리가 가지고있는 도구를 잘 사용합니다.

참고로 열이 대문자이기 때문에 .... SELECT dbo.ProperCase (LOWER (column))로 사용해야하는 것처럼 사용해야합니다. 실제로 낮은 항목에서도 5,000 개 항목 (1 초도 아님)의 테이블에서 매우 빠르게 작동합니다.

국제화에 대한 수많은 의견에 대한 응답으로 SQL Server의 상위 및 하위 구현에만 의존하는 모든 ASCII 문자를 처리하는 다음 구현을 제시합니다. 여기서 사용하는 변수는 VARCHAR이므로 ASCII 값만 보유 할 수 있습니다. 더 많은 국제 알파벳을 사용하려면 NVARCHAR을 사용해야합니다. 논리는 비슷하지만 ASCII AND CHAR 대신 UNICODE와 NCHAR을 사용해야하며 replace 문은 훨씬 더 커집니다 ....

-- Code Generator for expression
DECLARE @x  INT,
    @c  CHAR(1),
    @sql    VARCHAR(8000),
    @count  INT
SEt @x = 0
SET @count = 0
SET @sql = '@str' -- actual variable you want to replace
WHILE @x < 256
BEGIN
    SET @c = CHAR(@x)
    -- Only generate replacement expression for characters where upper and lowercase differ
    IF @x = ASCII(LOWER(@c)) AND @x != ASCII(UPPER(@c))
    BEGIN
        SET @sql = 'REPLACE(' + @sql + ', '' ' + @c+  ''', '' ' + UPPER(@c) + ''')'
        SET @count = @count + 1
    END
    SET @x = @x + 1
END
PRINT @sql
PRINT 'Total characters substituted: ' + CONVERT(VARCHAR(255), @count)

기본적으로 내 방법의 전제는 효율성을 위해 사전 컴퓨팅을 거래하는 것입니다. 전체 ASCII 구현은 다음과 같습니다.

IF OBJECT_ID('dbo.ProperCase') IS NOT NULL
    DROP FUNCTION dbo.ProperCase
GO
CREATE FUNCTION dbo.PROPERCASE (
    @str VARCHAR(8000))
RETURNS VARCHAR(8000)
AS
BEGIN
    SET @str = ' ' + @str
SET @str =     REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(@str, ' a', ' A'), ' b', ' B'), ' c', ' C'), ' d', ' D'), ' e', ' E'), ' f', ' F'), ' g', ' G'), ' h', ' H'), ' i', ' I'), ' j', ' J'), ' k', ' K'), ' l', ' L'), ' m', ' M'), ' n', ' N'), ' o', ' O'), ' p', ' P'), ' q', ' Q'), ' r', ' R'), ' s', ' S'), ' t', ' T'), ' u', ' U'), ' v', ' V'), ' w', ' W'), ' x', ' X'), ' y', ' Y'), ' z', ' Z'), ' š', ' Š'), ' œ', ' Œ'), ' ž', ' Ž'), ' à', ' À'), ' á', ' Á'), ' â', ' Â'), ' ã', ' Ã'), ' ä', ' Ä'), ' å', ' Å'), ' æ', ' Æ'), ' ç', ' Ç'), ' è', ' È'), ' é', ' É'), ' ê', ' Ê'), ' ë', ' Ë'), ' ì', ' Ì'), ' í', ' Í'), ' î', ' Î'), ' ï', ' Ï'), ' ð', ' Ð'), ' ñ', ' Ñ'), ' ò', ' Ò'), ' ó', ' Ó'), ' ô', ' Ô'), ' õ', ' Õ'), ' ö', ' Ö'), ' ø', ' Ø'), ' ù', ' Ù'), ' ú', ' Ú'), ' û', ' Û'), ' ü', ' Ü'), ' ý', ' Ý'), ' þ', ' Þ'), ' ÿ', ' Ÿ')
    RETURN RIGHT(@str, LEN(@str) - 1)
END
GO

돌아가서 대문자가 아닌 데이터를 가져 오기에는 너무 늦었습니까?

von Neumann 's, McCain 's, DeGuzman 's 및 Johnson-Smith 's는 고객 기반의 처리 결과를 좋아하지 않을 수 있습니다.

또한 이것은 데이터의 일회성 업그레이드를 의도 한 것 같습니다. 수정 된 이름을 DB로 내보내고, 필터링 / 수정하고, 다시 가져 오는 것이 더 쉬울 수 있습니다. 그러면 SQL이 아닌 접근 방식을 사용하여 이름을 수정할 수 있습니다.

다음은 SQLTeam.com Forums @ http://www.sqlteam.com/forums/topic.asp?TOPIC_ID=47718 에서 찾은 또 다른 변형입니다 .

create FUNCTION PROPERCASE
(
--The string to be converted to proper case
@input varchar(8000)
)
--This function returns the proper case string of varchar type
RETURNS varchar(8000)
AS
BEGIN
IF @input IS NULL
BEGIN
--Just return NULL if input string is NULL
RETURN NULL
END

--Character variable declarations
DECLARE @output varchar(8000)
--Integer variable declarations
DECLARE @ctr int, @len int, @found_at int
--Constant declarations
DECLARE @LOWER_CASE_a int, @LOWER_CASE_z int, @Delimiter char(3), @UPPER_CASE_A int, @UPPER_CASE_Z int

--Variable/Constant initializations
SET @ctr = 1
SET @len = LEN(@input)
SET @output = ''
SET @LOWER_CASE_a = 97
SET @LOWER_CASE_z = 122
SET @Delimiter = ' ,-'
SET @UPPER_CASE_A = 65
SET @UPPER_CASE_Z = 90

WHILE @ctr <= @len
BEGIN
--This loop will take care of reccuring white spaces
WHILE CHARINDEX(SUBSTRING(@input,@ctr,1), @Delimiter) > 0
BEGIN
SET @output = @output + SUBSTRING(@input,@ctr,1)
SET @ctr = @ctr + 1
END

IF ASCII(SUBSTRING(@input,@ctr,1)) BETWEEN @LOWER_CASE_a AND @LOWER_CASE_z
BEGIN
--Converting the first character to upper case
SET @output = @output + UPPER(SUBSTRING(@input,@ctr,1))
END
ELSE
BEGIN
SET @output = @output + SUBSTRING(@input,@ctr,1)
END

SET @ctr = @ctr + 1

WHILE CHARINDEX(SUBSTRING(@input,@ctr,1), @Delimiter) = 0 AND (@ctr <= @len)
BEGIN
IF ASCII(SUBSTRING(@input,@ctr,1)) BETWEEN @UPPER_CASE_A AND @UPPER_CASE_Z
BEGIN
SET @output = @output + LOWER(SUBSTRING(@input,@ctr,1))
END
ELSE
BEGIN
SET @output = @output + SUBSTRING(@input,@ctr,1)
END
SET @ctr = @ctr + 1
END

END
RETURN @output
END



GO
SET QUOTED_IDENTIFIER OFF
GO
SET ANSI_NULLS ON
GO

나는 악마가 세부 사항 (특히 사람들의 개인 데이터에 관한 것)에 있고 적절하게 대문자로 이름을 사용하는 것이 매우 좋을 것이라는 것을 알고 있지만 위와 같은 번거 로움은 우리 사이에서 실용적이고 시간을 의식하는 사람들이 다음을 사용하는 이유입니다. :

SELECT UPPER('Put YoUR O'So oddLy casED McWeird-nAme von rightHERE here')

내 경험상 사람들은 그들의 이름을 잘 볼 수 있습니다.

참조 : 러시아인이 연필을 사용했습니다!

에 대해 방금 배웠습니다 InitCap().

다음은 몇 가지 샘플 코드입니다.

SELECT ID
      ,InitCap(LastName ||', '|| FirstName ||' '|| Nvl(MiddleName,'')) AS RecipientName
FROM SomeTable

이것은 SSMS에서 작동했습니다.

Select Jobtitle,
concat(Upper(LEFT(jobtitle,1)), SUBSTRING(jobtitle,2,LEN(jobtitle))) as Propercase
From [HumanResources].[Employee]

모든 데이터가 한 단어에 불과하다는 것을 알고 있다면 여기에 해결책이 있습니다. 먼저 열을 모두 더 낮게 업데이트 한 후 다음을 실행하십시오.

    update tableName set columnName = 
    upper(SUBSTRING(columnName, 1, 1)) + substring(columnName, 2, len(columnName)) from tableName

최근에이 문제를 해결해야했고 내가 원하는 모든 것을 제대로 처리하지 못한 후 다음을 생각해 냈습니다. 이것은 전체 문장, 특수 단어 처리의 경우를 수행합니다. 우리는 또한 많은 간단한 방법이 처리하지만 더 복잡한 방법이 아닌 단일 문자 '단어'에 문제가있었습니다. 단일 반환 변수, 루프 또는 커서 없음.

CREATE FUNCTION ProperCase(@Text AS NVARCHAR(MAX))
RETURNS NVARCHAR(MAX)
AS BEGIN

    DECLARE @return NVARCHAR(MAX)

    SELECT @return = COALESCE(@return + ' ', '') + Word FROM (
         SELECT CASE
            WHEN LOWER(value) = 'llc' THEN UPPER(value)
            WHEN LOWER(value) = 'lp' THEN UPPER(value) --Add as many new special cases as needed
            ELSE
               CASE WHEN LEN(value) = 1
               THEN UPPER(value)
               ELSE UPPER(LEFT(value, 1)) + (LOWER(RIGHT(value, LEN(value) - 1)))
              END
            END AS Word
         FROM STRING_SPLIT(@Text, ' ')
     ) tmp

     RETURN @return
END

데이터를 복사하여 MS Word에 붙여넣고 내장 된 텍스트 변환을 사용하여 "각 단어를 대문자 화"하십시오. 예외를 해결하려면 원본 데이터와 비교하십시오. "MacDonald"및 "IBM"유형 예외를 수동으로 회피하는 방법은 볼 수 없지만 이것이 FWIW를 수행 한 방법입니다.