Viết hoa chỉ chữ cái đầu tiên của mỗi từ trong mỗi câu trong SQL Server

Tôi muốn viết hoa chữ cái đầu tiên của mỗi từ trong mỗi câu trong cột SQL.

Ví dụ: nếu câu là:

'Tôi thích phim ảnh'

sau đó tôi cần đầu ra:

'Tôi thích phim ảnh'

Truy vấn:

declare @a varchar(15) 

set @a = 'qWeRtY kEyBoArD'

select @a as [Normal text],
upper(@a) as [Uppercase text],
lower(@a) as [Lowercase text],
upper(left(@a,1)) + lower(substring(@a,2,len(@a))) as [Capitalize first letter only]

Ở đây tôi đã viết hoa, viết hoa và viết hoa chữ cái đầu tiên trong cột của mình (ở đây tôi chỉ đặt một từ ngẫu nhiên).

Đây là kết quả của tôi:

Có bất kỳ khả năng để làm điều đó?

Bất kỳ khả năng để có được kết quả mà không cần sử dụng chức năng do người dùng xác định?

Tôi cần đầu ra Qwerty Keyboard

declare @a varchar(30); 

set @a = 'qWeRtY kEyBoArD TEST<>&''"X';

select stuff((
       select ' '+upper(left(T3.V, 1))+lower(stuff(T3.V, 1, 1, ''))
       from (select cast(replace((select @a as '*' for xml path('')), ' ', '<X/>') as xml).query('.')) as T1(X)
         cross apply T1.X.nodes('text()') as T2(X)
         cross apply (select T2.X.value('.', 'varchar(30)')) as T3(V)
       for xml path(''), type
       ).value('text()[1]', 'varchar(30)'), 1, 1, '') as [Capitalize first letter only];

Điều này đầu tiên chuyển đổi chuỗi thành XML bằng cách thay thế tất cả các khoảng trắng bằng thẻ trống <X/>. Sau đó, nó băm nhỏ XML để có được một từ trên mỗi hàng bằng cách sử dụng nodes(). Để đưa các hàng trở lại một giá trị, nó sử dụng for xml paththủ thuật.

Trong SQL Server 2016, bạn có thể làm điều này với R, vd

-- R capitalisation code stolen from here:
-- http://stackoverflow.com/questions/6364783/capitalize-the-first-letter-of-both-words-in-a-two-word-string

EXEC sp_execute_external_script
    @language = N'R',
    @script = N'
simpleCap <- function(x) {
  s <- strsplit(x, " ")[[1]]
  paste(toupper(substring(s, 1,1)), substring(s, 2),
        sep="", collapse=" ")
}             

OutputDataSet <- as.data.frame((sapply(as.vector(InputDataSet$xtext), simpleCap)))',
    @input_data_1 = N'SELECT LOWER(testString) xtext FROM dbo.testStrings'
WITH RESULT SETS ( ( properCase VARCHAR(50) NOT NULL ) );

Cho dù bạn nên hay không là một câu hỏi khác nhau :)

Có thể tôi đang ngớ ngẩn nhưng kiểm tra truy vấn bên dưới tôi đã viết với một số được cung cấp, điều này có vẻ hiệu quả hơn một chút (tùy thuộc vào lập chỉ mục).

Mã này hơi ngu ngốc, nhưng không có gì để nói rằng nếu nó trông ngu ngốc nhưng nó hoạt động thì nó không ngu ngốc.

Begin

    Declare @text Varchar(30);

    Set @text = 'qWeRtY kEyBoArD TEST<>&''"X';

    Declare @1 Varchar(2)= ' a'
      , @2 Varchar(2)= ' b'
      , @3 Varchar(2)= ' c'
      , @4 Varchar(2)= ' d'
      , @5 Varchar(2)= ' e'
      , @6 Varchar(2)= ' f'
      , @7 Varchar(2)= ' g'
      , @8 Varchar(2)= ' h'
      , @9 Varchar(2)= ' i'
      , @10 Varchar(2)= ' j'
      , @11 Varchar(2)= ' k'
      , @12 Varchar(2)= ' l'
      , @13 Varchar(2)= ' m'
      , @14 Varchar(2)= ' n'
      , @15 Varchar(2)= ' o'
      , @16 Varchar(2)= ' p'
      , @17 Varchar(2)= ' q'
      , @18 Varchar(2)= ' r'
      , @19 Varchar(2)= ' s'
      , @20 Varchar(2)= ' t'
      , @21 Varchar(2)= ' u'
      , @22 Varchar(2)= ' v'
      , @23 Varchar(2)= ' w'
      , @24 Varchar(2)= ' x'
      , @25 Varchar(2)= ' y'
      , @26 Varchar(2)= ' z';

Set @text=' '+@text

    Select  LTrim(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(Lower(@text) ,
                                                              @1 , Upper(@1)) ,
                                                              @2 , Upper(@2)) ,
                                                              @3 , Upper(@3)) ,
                                                              @4 , Upper(@4)) ,
                                                              @5 , Upper(@5)) ,
                                                              @6 , Upper(@6)) ,
                                                              @7 , Upper(@7)) ,
                                                              @8 , Upper(@8)) ,
                                                              @9 , Upper(@9)) ,
                                                              @10 , Upper(@10)) ,
                                                              @11 , Upper(@11)) ,
                                                              @12 , Upper(@12)) ,
                                                              @13 , Upper(@13)) ,
                                                              @14 , Upper(@14)) ,
                                                              @15 , Upper(@15)) ,
                                                              @16 , Upper(@16)) ,
                                                              @17 , Upper(@17)) ,
                                                              @18 , Upper(@18)) ,
                                                              @19 , Upper(@19)) ,
                                                              @20 , Upper(@20)) ,
                                                            @21 , Upper(@21)) ,
                                                    @22 , Upper(@22)) , @23 ,
                                            Upper(@23)) , @24 , Upper(@24)) ,
                            @25 , Upper(@25)) , @26 , Upper(@26)));


end

Một tùy chọn khác là xử lý việc này thông qua SQLCLR. Thậm chí còn có một phương thức đã có sẵn trong .NET thực hiện điều này: TextInfo.ToTitleCase (in System.Globalization). Phương pháp này sẽ viết hoa chữ thường đầu tiên của mỗi từ và viết thường các chữ cái còn lại. Không giống như các đề xuất khác ở đây, nó cũng bỏ qua các từ trong tất cả các chữ hoa, giả sử chúng là các từ viết tắt. Tất nhiên, nếu hành vi này là mong muốn, sẽ dễ dàng cập nhật bất kỳ đề xuất T-SQL nào để thực hiện điều này.

Một lợi ích của phương thức .NET là nó có thể viết các chữ cái viết hoa là các ký tự bổ sung. Ví dụ: Deseret NHỎ THƯ OW có một bản đồ chữ hoa của Deseret VỐN THƯ OW ^{(cả chương trình như hộp khi tôi dán chúng vào đây)} , nhưng UPPER()chức năng không thay đổi phiên bản thấp hơn trường hợp để chữ hoa, ngay cả khi Collation mặc định cho Cơ sở dữ liệu hiện tại được đặt thành Latin1_General_100_CI_AS_SC. Điều này có vẻ phù hợp với tài liệu MSDN không liệt kê UPPERvà LOWERtrong biểu đồ các chức năng hoạt động khác nhau khi sử dụng _SCCollation: Collation và Unicode Support: Ký tự bổ sung .

SELECT N'DESERET SMALL LETTER OW' AS [Label], NCHAR(0xD801)+NCHAR(0xDC35) AS [Thing]
UNION ALL
SELECT N'DESERET CAPITAL LETTER OW' AS [Label], NCHAR(0xD801)+NCHAR(0xDC0D) AS [Thing]
UNION ALL
SELECT N'SmallButShouldBeCapital' AS [Label], UPPER(NCHAR(0xD801)+NCHAR(0xDC35)) AS [Thing]

Trả về (được phóng to để bạn thực sự có thể thấy Nhân vật bổ sung):

Bạn có thể xem danh sách đầy đủ (và hiện tại) các ký tự chữ thường và thay đổi thành chữ hoa bằng cách sử dụng tính năng tìm kiếm sau tại Unicode.org (bạn có thể xem các Ký tự bổ sung bằng cách cuộn xuống cho đến khi bạn đến "MÔ TẢ" phần, hoặc chỉ cần nhấn Control-Fvà tìm kiếm từ đó):

http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AChanges_When_Titlecasing%3DYes%3A%5D

Mặc dù thành thật mà nói, đây không phải là một lợi ích to lớn vì nghi ngờ rằng bất kỳ ai thực sự đang sử dụng bất kỳ Nhân vật bổ sung nào có thể được đặt theo tiêu đề. Dù bằng cách nào, đây là mã SQLCLR:

using System.Data.SqlTypes;
using System.Globalization;
using Microsoft.SqlServer.Server;

public class TitleCasing
{
    [return: SqlFacet(MaxSize = 4000)]
    [Microsoft.SqlServer.Server.SqlFunction(IsDeterministic = true, IsPrecise = true)]
    public static SqlString TitleCase([SqlFacet(MaxSize = 4000)] SqlString InputString)
    {
        TextInfo _TxtInf = new CultureInfo(InputString.LCID).TextInfo;
        return new SqlString (_TxtInf.ToTitleCase(InputString.Value));
    }
}

Dưới đây là đề xuất của @ MikaelEriksson - đã sửa đổi một chút để xử lý NVARCHARdữ liệu cũng như bỏ qua các từ có chữ hoa (để phù hợp hơn với hành vi của phương thức .NET) - cùng với thử nghiệm triển khai T-SQL đó và của triển khai SQLCLR:

SET NOCOUNT ON;
DECLARE @a NVARCHAR(50);

SET @a = N'qWeRtY kEyBoArD TEST<>&''"X one&TWO '
         + NCHAR(0xD801)+NCHAR(0xDC28)
         + N'pPLe '
         + NCHAR(0x24D0) -- ⓐ  Circled "a"
         + NCHAR(0xFF24) -- Ｄ  Full-width "D"
         + N'D u'
         + NCHAR(0x0308) -- ̈  (combining diaeresis / umlaut)
         + N'vU'
         + NCHAR(0x0308) -- ̈  (combining diaeresis / umlaut)
         + N'lA';
SELECT @a AS [Original];

SELECT STUFF((
       SELECT N' '
              + IIF(UPPER(T3.V) <> T3.V COLLATE Latin1_General_100_BIN2, 
                    UPPER(LEFT(T3.V COLLATE Latin1_General_100_CI_AS_SC, 1))
                    + LOWER(STUFF(T3.V COLLATE Latin1_General_100_CI_AS_SC, 1, 1, N'')),
                    T3.V)
       FROM (SELECT CAST(REPLACE((SELECT @a AS N'*' FOR XML PATH('')), N' ', N'<X/>')
                    AS XML).query('.')) AS T1(X)
       CROSS APPLY T1.X.nodes('text()') AS T2(X)
       CROSS APPLY (SELECT T2.X.value('.', 'NVARCHAR(70)')) AS T3(V)
       FOR XML PATH(''), TYPE
       ).value('text()[1]', 'NVARCHAR(70)') COLLATE Latin1_General_100_CI_AS_SC, 1, 1, N'')
                AS [Capitalize first letter only];

SELECT dbo.TitleCase(@a) AS [ToTitleCase];

Một điểm khác biệt trong hành vi là việc triển khai T-SQL cụ thể này chỉ phân tách trên các khoảng trắng, trong khi ToTitleCase()phương thức này coi hầu hết các chữ cái không phải là dấu tách từ (do đó có sự khác biệt trong cách xử lý phần "một & HAI").

Cả hai triển khai xử lý kết hợp trình tự chính xác. Mỗi chữ cái có dấu trong "üvÜlA" bao gồm một chữ cái cơ sở và một chữ cái kết hợp / âm sắc (hai dấu chấm trên mỗi chữ cái) và chúng được chuyển đổi chính xác sang trường hợp khác trong cả hai bài kiểm tra.

Cuối cùng, một nhược điểm bất ngờ đối với phiên bản SQLCLR là khi đưa ra nhiều thử nghiệm khác nhau, tôi đã phát hiện ra một lỗi trong mã .NET liên quan đến việc xử lý Thư được khoanh tròn (hiện đã được báo cáo trên Microsoft Connect - CẬP NHẬT: Kết nối đã được báo cáo chuyển đến /dev/null- theo nghĩa đen - vì vậy tôi có thể cần phải gửi lại nếu vấn đề vẫn còn tồn tại). Thư viện .NET coi các Thư được khoanh tròn là các dấu tách từ, đó là lý do tại sao nó không biến "D" thành ""d" như bình thường.

FYI

Hàm SQLCLR được thực hiện trước đóng gói TextInfo.ToTitleCasephương thức được đề cập ở trên hiện có sẵn trong phiên bản SQL # miễn phí (mà tôi đã viết) dưới dạng String_ToTitleCase và String_ToTitleCase4k .

😺

Thay thế cho câu trả lời của Mikael Eriksson , bạn có thể xem xét sử dụng xử lý T-SQL độc quyền của cài đặt biến trong các câu lệnh chọn nhiều hàng.

Trong SQL Server, khi một biến được đặt thành một phần của câu lệnh CHỌN, mỗi hàng sẽ thực hiện một lần lặp của logic đã đặt.

Mọi người thường sử dụng phương pháp này để nối các chuỗi, mặc dù nó không được hỗ trợ và có một số vấn đề được ghi lại chính thức với nó . Vấn đề chính thức liên quan đến các đặc điểm ĐẶT HÀNG theo cụ thể và chúng tôi không cần điều đó ở đây, vì vậy có lẽ đó là một lựa chọn an toàn.

Ở đây, chúng tôi lặp lại 26 chữ cái của bảng chữ cái và thay thế chúng bằng một phiên bản chữ hoa nếu chúng được đặt trước một khoảng trắng. (Chúng tôi chuẩn bị chuỗi ban đầu bằng cách viết hoa chữ cái đầu tiên và làm cho phần còn lại viết thường, như bạn đã làm trong câu hỏi của mình.)

SQL hơi phức tạp vì nó yêu cầu sử dụng Bảng Tally-- một bảng số-- để tạo ra 26 lần lặp thay thế mà nó đang làm. Bạn có thể tạo một hàm xác định người dùng có giá trị bảng nội tuyến (TVF) để tạo bảng số đó hoặc thậm chí bạn có thể sử dụng bảng vật lý.

Một nhược điểm của tùy chọn này là nó không thể là một phần của TVF nội tuyến vì nó cần liên quan đến việc đặt biến. Vì vậy, nếu bạn muốn áp dụng phương pháp này cho một cột của đầu ra của mình, bạn sẽ cần phải bọc nó thành một TVF đa câu lệnh hoặc hàm do người dùng xác định vô hướng.

Tuy nhiên, kế hoạch truy vấn của nó đơn giản hơn nhiều và có lẽ nhanh hơn đáng kể so với phương thức XML. Bạn cũng có thể tranh luận rằng nó cũng dễ hiểu hơn (đặc biệt là nếu bạn có bảng kiểm đếm của riêng mình).

DECLARE
    @a VARCHAR(15) = 'qWeRtY kEyBoArD';

SELECT
    @a = UPPER(LEFT(@a,1)) + LOWER(SUBSTRING(@a,2,LEN(@a)));

WITH TallyTableBase AS
(
    SELECT
        0 AS n
    FROM    (VALUES(0),(0),(0),(0),(0),(0),(0),(0),(0),(0)) AS t(n)
)
SELECT
    @a = REPLACE(@a, ' ' + CHAR(n.n), ' ' + CHAR(n.n))
FROM        (
                SELECT      TOP 26 ROW_NUMBER() OVER (ORDER BY (SELECT 1)) + 64 AS n
                FROM        TallyTableBase a
                CROSS JOIN  TallyTableBase b
            ) AS n;

SELECT
    @a AS [NewValue];

(Tôi đã thử nghiệm điều này bằng cách sử dụng chuỗi lớn hơn nhiều và khoảng 6ms so với 14ms cho giải pháp XML.)

Có một số hạn chế bổ sung với giải pháp này. Như đã viết, nó giả sử một đối chiếu không nhạy cảm trong trường hợp, mặc dù bạn có thể loại bỏ vấn đề đó bằng cách chỉ định đối chiếu hoặc chạy LCASE trên cụm từ tìm kiếm, với chi phí của một số hiệu suất. Nó cũng chỉ giải quyết các chữ cái ASCII tiêu chuẩn và dựa vào vị trí của chúng trong bộ ký tự , vì vậy nó sẽ không làm gì với ñ.

Giả sử bạn chỉ tìm cách viết hoa các từ sau một khoảng trắng, đây là một cách khác bạn có thể làm điều đó.

DECLARE @String VARCHAR(1000)
SET @String = 'qWeRtY kEyBoArD tEst'

/*
Set the string to all lower case and
add a space at the beginning to ensure
the first letter gets capitalized
in the CTE
*/
SET @String = LOWER(' ' + @String)  

/*
Use a Tally "Table" as a means of
replacing the letter after the space
with the capitalize version of the
letter
*/
;WITH TallyTable
AS
(
    SELECT TOP 1000 ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as N
    FROM master.sys.all_columns a CROSS JOIN master.sys.all_columns b

)
SELECT @String = REPLACE(@String,SUBSTRING(@String,CHARINDEX(' ',@String,N), 2),UPPER(SUBSTRING(@String,CHARINDEX(' ',@String,N), 2)))
FROM TallyTable
WHERE CHARINDEX(' ',@String,N) <> 0

--Remove the space added to the beginning of the string earlier
SET @String = RIGHT(@String,LEN(@String) - 1)

Có thể không chống đạn nhưng tôi hy vọng nó là một đóng góp hữu ích cho chủ đề này.

DECLARE @t VARCHAR(50) = 'the quick brown fox jumps over the lazy dog', @i INT = 0

DECLARE @chk VARCHAR(1)

WHILE @i <= LEN(@t)
BEGIN
    SELECT @chk=SUBSTRING(@t,@i,1)
        IF @chk = CHAR(32)
        BEGIN
            SET @t = STUFF(@t,@i+1,1,UPPER(SUBSTRING(@t,@i+1,1)))
        END
    SET @i=@i+1
END
PRINT @t

Dưới đây là quy trình tôi đã sử dụng trong cơ sở dữ liệu Firebird để thực hiện việc này. Có lẽ có thể được làm sạch rất nhiều nhưng nó đã hoàn thành công việc cho tôi.

set term ~;

Create Procedure EachWordCap

As

Declare Variable lcaption varchar(33);
Declare Variable lcurrentpos integer;
Declare Variable lstringlen integer;
begin
    for select ' ' || trim(lower(imagedata.imagename)) from imagedata
    where imagedata.imagename is not null and imagedata.imagename != ''
    into :lcaption
    do 
    begin
        lcurrentpos = 0;
        lstringlen = char_length(lcaption);
        while (lcurrentpos != 1) do
        begin
            lcurrentpos = position(' ', lcaption, iif(lcurrentpos = 0, 1,lcurrentpos)) + 1 ;
            lcaption = left(lcaption,lcurrentpos - 1) || upper(substring(lcaption from lcurrentpos for 1)) || right(lcaption,lstringlen - lcurrentpos);
        end
        --Put what you want to do with the text in here
    end
end~
set term ;~

CTE đệ quy là khá tốt cho loại điều này.

Có lẽ không đặc biệt hiệu quả đối với các hoạt động lớn, nhưng cho phép loại hoạt động này trong một câu lệnh chọn SQL thuần túy:

declare @a varchar(100) 

set @a = 'tHe qUiCk bRoWn FOX jumps   OvEr The lAZy dOG';

WITH [CTE] AS (
  SELECT CAST(upper(Left(@a,1)) + lower(substring(@a,2,len(@a))) AS VARCHAR(100)) AS TEXT,
         CHARINDEX(' ',@a) AS NEXT_SPACE
  UNION ALL
  SELECT CAST(Left(TEXT,NEXT_SPACE) + upper(SubString(TEXT,NEXT_SPACE+1,1)) + SubString(TEXT,NEXT_SPACE+2,1000) AS VARCHAR(100)),
         CHARINDEX(' ',TEXT, NEXT_SPACE+1)
  FROM [CTE]
  WHERE NEXT_SPACE <> 0
)

SELECT TEXT
FROM [CTE]
WHERE NEXT_SPACE = 0

Đầu ra:

The Quick Brown Fox Jumps   Over The Lazy Dog

Tôi thích phiên bản này. Nó đơn giản và có thể được sử dụng để tạo một hàm, bạn chỉ cần có đúng phiên bản SQL Server:

WITH words
AS (
    SELECT upper(left(Value, 1)) + lower(substring(Value, 2, len(Value))) AS word
    FROM STRING_SPLIT('Lorem ipsum dolor sit amet.', ' ')
    )
SELECT STRING_AGG(words.word, ' ')
FROM words

DECLARE @someString NVARCHAR(MAX) = 'In this WHILE LOOP example' 

DECLARE @result NVARCHAR(MAX) =Upper(SUBSTRING(@someString, 1, 1))

DECLARE @index INT =2 

WHILE LEN(@someString)>@index

BEGIN

SET @result= @result+CASE WHEN CHARINDEX(' ',@someString,@index)<>0 THEN LOWER(SUBSTRING(@someString, @index, CHARINDEX(' ',@someString,@index)-@index+1)) +Upper(SUBSTRING(@someString, CHARINDEX(' ',@someString,@index)+1, 1)) ELSE  LOWER(SUBSTRING(@someString,@index, LEN(@someString) )) END

SET @index=CASE WHEN CHARINDEX(' ',@someString,@index)<>0 THEN CHARINDEX(' ',@someString,@index)+2 ELSE  LEN(@someString)+1  END

 END

SELECT  @result 

Tôi hy vọng sẽ giúp ...

Kiểm tra dữ liệu

declare @word varchar(100)
with good as (select 'good' as a union select 'nice' union select 'fine')
select @word = (SELECT TOP 1 a FROM good ORDER BY NEWID())

Thực hiện

select substring(Upper(@word),1,1) + substring(@word, 2, LEN(@word))