Großschreiben Sie in SQL Server nur den ersten Buchstaben jedes Wortes jedes Satzes

Ich möchte nur den ersten Buchstaben jedes Wortes jedes Satzes in einer SQL-Spalte groß schreiben.

Zum Beispiel, wenn der Satz ist:

'Ich mag Filme'

dann brauche ich die ausgabe:

'Ich mag Filme'

Abfrage:

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]

Hier habe ich nur den ersten Buchstaben in meiner Spalte groß und klein geschrieben (hier habe ich nur ein zufälliges Wort eingegeben).

Hier sind meine Ergebnisse:

Gibt es dafür Möglichkeiten?

Gibt es Möglichkeiten, Ergebnisse zu erzielen, ohne eine benutzerdefinierte Funktion zu verwenden?

Ich brauche die Ausgabe 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];

Dadurch wird die Zeichenfolge zunächst in XML konvertiert, indem alle Leerzeichen durch das leere Tag ersetzt werden <X/>. Anschließend wird die XML-Datei zerkleinert, um mit ein Wort pro Zeile zu erhalten nodes(). Um die Zeilen wieder auf einen Wert zu bringen, wird der for xml pathTrick verwendet.

In SQL Server 2016 können Sie dies mit R tun, z

-- 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 ) );

Ob Sie sollten oder nicht, ist eine andere Frage:)

Vielleicht bin ich dumm, aber wenn ich die unten stehende Abfrage mit einigen der bereitgestellten vergleiche, scheint dies ein bisschen effizienter zu sein (abhängig von der Indizierung).

Der Code ist ein bisschen dumm, aber es gibt keinen Spruch, der besagt, dass es nicht dumm ist, wenn es dumm aussieht, aber es funktioniert.

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

Eine andere Möglichkeit besteht darin, dies über SQLCLR zu handhaben. Es gibt sogar eine Methode, die in .NET bereits verfügbar ist: TextInfo.ToTitleCase (inSystem.Globalization ). Bei dieser Methode wird der erste Buchstabe jedes Wortes in Großbuchstaben und die verbleibenden Buchstaben in Kleinbuchstaben geschrieben. Im Gegensatz zu den anderen Vorschlägen werden hier auch Wörter übersprungen, bei denen es sich um Akronyme handelt. Wenn dieses Verhalten gewünscht wird, ist es natürlich einfach genug, einen der T-SQL-Vorschläge zu aktualisieren, um dies ebenfalls zu tun.

Ein Vorteil der .NET-Methode besteht darin, dass es sich bei Großbuchstaben um Zusatzzeichen handelt. Beispiel: DESERET SMALL LETTER OW enthält eine Zuordnung von DESERET CAPITAL LETTER OW in Großbuchstaben ^{(beide werden als Kästchen} angezeigt, ^{wenn ich sie hier} einfüge ⁾ , aber die UPPER()Funktion ändert die Kleinbuchstabenversion nicht in Großbuchstaben, selbst wenn Die Standardkollatierung für die aktuelle Datenbank ist auf festgelegt Latin1_General_100_CI_AS_SC. Dies scheint mit der MSDN-Dokumentation übereinzustimmen, in der Funktionen, die sich bei Verwendung einer Kollatierung anders verhalten, nicht aufgelistet UPPERund LOWERin der Tabelle nicht aufgeführt sind _SC: Kollatierung und Unicode-Unterstützung: Zusatzzeichen .

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]

Rückgabe (vergrößert, damit Sie das Zusatzzeichen tatsächlich sehen können):

Mit der folgenden Suchfunktion bei Unicode.org können Sie die vollständige (und aktuelle) Liste der Kleinbuchstaben anzeigen und in Großbuchstaben ändern. Abschnitt, oder drücken Sie einfach Control-Fund suchen Sie nach diesem Wort):

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

Obwohl dies, um ehrlich zu sein, kein großer Vorteil ist, da es zweifelhaft ist, dass tatsächlich jemand einen der Zusatzcharaktere verwendet, die mit einem Titel versehen werden können. In beiden Fällen ist hier der SQLCLR-Code:

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));
    }
}

Hier ist der Vorschlag von @ MikaelEriksson - leicht modifiziert, um NVARCHARDaten zu verarbeiten sowie Wörter zu überspringen, die alle in Großbuchstaben geschrieben sind (um dem Verhalten der .NET-Methode besser zu entsprechen) - zusammen mit einem Test dieser T-SQL-Implementierung und von die SQLCLR-Implementierung:

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];

Ein weiterer Unterschied im Verhalten besteht darin, dass diese spezielle T-SQL-Implementierung sich nur auf Leerzeichen aufteilt, wohingegen die ToTitleCase()Methode die meisten Nicht-Buchstaben als Worttrennzeichen betrachtet (daher der Unterschied in der Behandlung des "one & TWO" -Teils).

Beide Implementierungen behandeln das korrekte Kombinieren von Sequenzen. Jeder der akzentuierten Buchstaben in "üvÜlA" besteht aus einem Grundbuchstaben und einer Kombination aus Diaeresis / Umlaut (die beiden Punkte über jedem Buchstaben) und wird in beiden Tests korrekt in den anderen Fall umgewandelt.

Schließlich ist ein unerwarteter Nachteil der SQLCLR-Version, dass ich bei der Entwicklung verschiedener Tests einen Fehler im .NET-Code gefunden habe, der mit der Behandlung der eingekreisten Buchstaben zusammenhängt (was jetzt der Fall war) Microsoft Connect gemeldet wurde - UPDATE: Connect war verschoben nach /dev/null- im wahrsten Sinne des Wortes -, daher muss ich dies möglicherweise erneut einreichen, wenn das Problem weiterhin besteht. Die .NET-Bibliothek behandelt die eingekreisten Buchstaben als Worttrennzeichen, weshalb das "ⓐＤD" nicht wie gewünscht in "Ⓐｄd" umgewandelt wird.

Zu Ihrer Information

Eine vorgefertigte SQLCLR-Funktion, die TextInfo.ToTitleCasedie oben erwähnte Methode kapselt, ist jetzt in der freien Version von SQL # (die ich geschrieben habe) als String_ToTitleCase verfügbar und String_ToTitleCase4k verfügbar .

😺

Als Alternative zu Mikael Erikssons Antwort könnten Sie die Verwendung der proprietären T-SQL-Behandlung der Variableneinstellung in mehrzeiligen select-Anweisungen in Betracht ziehen.

Wenn in SQL Server eine Variable als Teil einer SELECT-Anweisung festgelegt wird, führt jede Zeile eine Iteration der festgelegten Logik aus.

Leute verwenden diese Methode häufig zum Verketten von Zeichenfolgen, obwohl sie nicht unterstützt wird und es gibt einige offiziell dokumentierte Probleme gibt . Das offizielle Problem bezieht sich auf bestimmte ORDER BY-Merkmale, und das brauchen wir hier nicht. Vielleicht ist es eine sichere Option.

Hier iterieren wir über die 26 Buchstaben des Alphabets und ersetzen sie durch eine Großbuchstabenversion, wenn ihnen ein Leerzeichen vorangestellt ist. (Wir bereiten die Zeichenfolge zunächst vor, indem wir den ersten Buchstaben großschreiben und den Rest in Kleinbuchstaben schreiben, wie Sie es in Ihrer Frage getan haben.)

Die SQL ist etwas komplex, da sie die Verwendung einer Tally-Tabelle - einer Tabelle mit Zahlen - erfordert, um die 26 Iterationen des Ersetzens zu generieren, die sie ausführt. Sie können eine handliche Inline-Tabellenwert-Benutzerdefinierte Funktion (TVF) erstellen, um diese Zahlentabelle zu erstellen, oder Sie können sogar eine physische Tabelle verwenden.

Ein Nachteil dieser Option ist, dass sie nicht Teil einer Inline-TVF sein kann, da eine Variable festgelegt werden muss. Wenn Sie diese Methode auf eine Spalte Ihrer Ausgabe anwenden möchten, müssen Sie sie in eine TVF-Datei mit mehreren Anweisungen oder eine skalare benutzerdefinierte Funktion umbrechen.

Der Abfrageplan ist jedoch viel einfacher und wahrscheinlich wesentlich schneller als die XML-Methode. Sie könnten argumentieren, dass es auch einfacher zu verstehen ist (insbesondere, wenn Sie eine eigene Aufzählungstabelle haben).

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];

(Ich habe dies mit einer viel größeren Zeichenfolge getestet und es waren ungefähr 6 ms gegenüber 14 ms für die XML-Lösung.)

Es gibt eine Reihe zusätzlicher Einschränkungen bei dieser Lösung. Wie beschrieben wird eine Sortierung ohne Berücksichtigung der Groß- / Kleinschreibung vorausgesetzt. Sie können dieses Problem jedoch beheben, indem Sie eine Sortierung angeben oder LCASE für den Suchbegriff ausführen, was zu Lasten der Leistung geht. Es adressiert auch nur Standard-ASCII-Buchstaben und verlässt sich auf deren Platzierung im Zeichensatz , sodass es mit ñ nichts zu tun hätte.

Angenommen, Sie möchten nach einem Leerzeichen nur Wörter in Großbuchstaben schreiben, dann haben Sie hier eine andere Möglichkeit, dies zu tun.

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)

Könnte nicht kugelsicher sein, aber ich hoffe, es ist ein hilfreicher Beitrag zu diesem Thread.

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

Im Folgenden wird die Vorgehensweise beschrieben, die ich in einer Firebird-Datenbank verwendet habe, um dies zu tun. Wahrscheinlich kann man viel aufräumen, aber es hat die Arbeit für mich erledigt.

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 ;~

Rekursive CTEs sind ziemlich gut für diese Art von Dingen.

Wahrscheinlich nicht besonders effizient für große Operationen, ermöglicht aber diese Art von Operation in einer reinen SQL-Select-Anweisung:

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

Ausgabe:

The Quick Brown Fox Jumps   Over The Lazy Dog

Ich mag diese Version. Es ist einfach und kann zum Erstellen einer Funktion verwendet werden. Sie müssen nur die richtige Version von SQL Server haben:

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 

Ich hoffe würde helfen ...

Testdaten

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())

Implementierung

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