SQL Server: Machen Sie alle UPPER-Groß- / Kleinschreibung zu Proper Case / Title Case

Ich habe eine Tabelle, die als UPPER CASE importiert wurde, und möchte sie in Proper Case umwandeln. Welches Skript hat einer von Ihnen verwendet, um dies zu vervollständigen?

Hier ist eine UDF, die den Trick macht ...

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

Sie müssen es dennoch verwenden, um Ihre Daten zu aktualisieren.

Diese Funktion:

• "Proper Cases" sind alle "UPPER CASE" -Wörter, die durch Leerzeichen begrenzt sind
• lässt "Kleinbuchstaben" in Ruhe
• funktioniert auch für nicht englische Alphabete einwandfrei
• ist insofern portabel, als es keine ausgefallenen Funktionen der neuesten SQL Server-Versionen verwendet
• kann leicht geändert werden, um NCHAR und NVARCHAR für die Unicode-Unterstützung sowie jede beliebige Parameterlänge zu verwenden, die Sie für richtig halten
• Die Leerraumdefinition kann konfiguriert werden

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

Ergebnis:

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

Wenn Sie die CLR in SQL Server aktivieren können (erfordert 2005 oder höher), können Sie eine CLR-Funktion erstellen , die die integrierte Funktion TextInfo.ToTitleCase verwendet, mit der Sie in nur wenigen Fällen eine kulturbewusste Methode erstellen können Zeilen von Code.

Ich weiß, dass dies ein später Beitrag in diesem Thread ist, aber einen Blick wert. Diese Funktion funktioniert bei mir immer. Also dachte ich daran, es zu teilen.

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

Testanrufe:

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

Ergebnisse:

Ich bin etwas spät im Spiel, aber ich glaube, dass dies funktionaler ist und mit jeder Sprache funktioniert, einschließlich Russisch, Deutsch, Thailändisch, Vietnamesisch usw. Es wird alles nach 'oder - oder in Großbuchstaben schreiben. oder (oder) oder Leerzeichen (offensichtlich :).

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

Wenn Sie in SSIS Daten mit gemischten Groß- und Kleinschreibung importieren und eine Suche in einer Spalte mit der richtigen Groß- und Kleinschreibung durchführen müssen, werden Sie feststellen, dass die Suche fehlschlägt, wenn die Quelle gemischt ist und die Suchquelle korrekt ist. Sie werden auch feststellen, dass Sie die rechte und linke Funktion nicht verwenden können. Dies ist SSIS für SQL Server 2008r2 für abgeleitete Spalten. Hier ist eine Lösung, die für mich funktioniert:

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

Hier ist eine Version, die eine Sequenz- oder Zahlentabelle anstelle einer Schleife verwendet. Sie können die WHERE-Klausel so ändern, dass sie Ihren persönlichen Regeln für die Konvertierung eines Zeichens in Großbuchstaben entspricht. Ich habe gerade einen einfachen Satz beigefügt, der alle Buchstaben in Großbuchstaben schreibt, die von einem Nichtbuchstaben mit Ausnahme der Apostrophe vorangestellt werden. Dies bedeutet jedoch, dass 123apple eine Übereinstimmung mit dem "a" haben würde, da "3" kein Buchstabe ist. Wenn Sie nur Leerzeichen (Leerzeichen, Tabulator, Wagenrücklauf, Zeilenvorschub) möchten, können Sie das Muster '[^a-z]'durch ersetzen '[' + 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

Der Link, den ich oben gepostet habe, ist eine großartige Option, die das Hauptproblem anspricht: Wir können niemals programmatisch alle Fälle berücksichtigen (Smith-Jones, von Haussen, Dr. John Smith), zumindest nicht auf elegante Weise. Tony führt das Konzept eines Ausnahme- / Unterbrechungscharakters ein, um diese Fälle zu behandeln. Aufbauend auf der Idee von Cervo (oberste alle unteren Zeichen, denen Leerzeichen vorangestellt sind) könnten die Ersetzungsanweisungen stattdessen in einer einzigen tabellenbasierten Ersetzung zusammengefasst werden. Wirklich, jede Low / Up-Zeichenkombination könnte in @alpha eingefügt werden und die Anweisung würde sich nicht ändern:

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

Es wäre sinnvoll, nach Ausnahmen zu suchen, um sich um die von Neumanns, McCains, DeGuzmans und Johnson-Smiths zu kümmern.

Geliehen und verbessert auf @Richard Sayakanit Antwort. Dies behandelt mehrere Wörter. Wie seine Antwort verwendet dies keine UDFs, nur eingebaute Funktionen ( STRING_SPLITund STRING_AGG) und es ist ziemlich schnell. STRING_AGGerfordert SQL Server 2017, aber Sie können immer den STUFF/XMLTrick verwenden. Behandelt nicht jede Ausnahme, kann aber für viele Anforderungen hervorragend funktionieren.

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

Eine leichte Modifikation der Antwort von @ Galwegian - die sich zB St Elizabeth'sin verwandelt St Elizabeth'S.

Bei dieser Änderung werden Apostrophe als Kleinbuchstaben verwendet, wobei das s am Ende der angegebenen Zeichenfolge steht oder auf das s ein Leerzeichen folgt (und dies nur unter diesen Umständen).

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

Es wendet sich:

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

Die Kommentare anderer, dass unterschiedliche Lösungen für nicht-englische Eingaben vorzuziehen sind, bleiben der Fall.

Ich denke, Sie werden feststellen, dass Folgendes effizienter ist:

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

Die replace-Anweisung kann ausgeschnitten und direkt in eine SQL-Abfrage eingefügt werden. Es ist extrem hässlich, aber wenn Sie @str durch die Spalte ersetzen, an der Sie interessiert sind, zahlen Sie keinen Preis für einen impliziten Cursor wie bei den so veröffentlichten udfs. Ich finde, dass es selbst mit meiner UDF viel effizienter ist.

Oh, und anstatt die Ersetzungsanweisung von Hand zu generieren, verwenden Sie Folgendes:

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

Auf jeden Fall kommt es auf die Anzahl der Zeilen an. Ich wünschte, Sie könnten einfach s / \ b ([az]) / uc $ 1 / machen, aber na ja, wir arbeiten mit den Tools, die wir haben.

HINWEIS Sie müssten dies verwenden, da Sie es als .... SELECT dbo.ProperCase (LOWER (Spalte)) verwenden müssten, da die Spalte in Großbuchstaben geschrieben ist. Bei meiner Tabelle mit 5.000 Einträgen (nicht einmal eine Sekunde) funktioniert es sogar mit der unteren ziemlich schnell.

Als Antwort auf die zahlreichen Kommentare zur Internationalisierung stelle ich die folgende Implementierung vor, die jedes ASCII-Zeichen behandelt und sich nur auf die SQL Server-Implementierung von Upper und Lower stützt. Denken Sie daran, dass die Variablen, die wir hier verwenden, VARCHAR sind, was bedeutet, dass sie nur ASCII-Werte enthalten können. Um weitere internationale Alphabete verwenden zu können, müssen Sie NVARCHAR verwenden. Die Logik wäre ähnlich, aber Sie müssten UNICODE und NCHAR anstelle von ASCII UND CHAR verwenden, und die Ersetzungsanweisung wäre viel umfangreicher.

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

Grundsätzlich besteht die Prämisse meiner Methode darin, Pre-Computing gegen Effizienz zu tauschen. Die vollständige ASCII-Implementierung sieht wie folgt aus:

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

Ist es zu spät, zurück zu gehen und die Daten ohne Großbuchstaben zu erhalten?

Die von Neumanns, McCains, DeGuzmans und Johnson-Smiths Ihres Kundenstamms mögen das Ergebnis Ihrer Verarbeitung möglicherweise nicht ...

Ich vermute auch, dass dies ein einmaliges Upgrade der Daten sein soll? Es ist möglicherweise einfacher, die korrigierten Namen in die Datenbank zu exportieren, zu filtern / zu ändern und erneut zu importieren, und dann können Sie Nicht-SQL-Ansätze zur Namensfixierung verwenden ...

Hier ist eine weitere Variante, die ich in den SQLTeam.com-Foren unter http://www.sqlteam.com/forums/topic.asp?TOPIC_ID=47718 gefunden habe

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

Ich weiß, dass der Teufel im Detail steckt (insbesondere wenn es um die persönlichen Daten von Menschen geht) und dass es sehr schön wäre, Namen richtig groß zu schreiben, aber der oben genannte Ärger ist der Grund, warum die pragmatischen, zeitbewussten unter uns Folgendes verwenden ::

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

Nach meiner Erfahrung ist es für die Leute in Ordnung, IHREN NAMEN zu sehen ... selbst wenn es die Hälfte eines Satzes ist.

Siehe: Die Russen haben einen Bleistift benutzt!

Ich habe gerade davon erfahren InitCap() .

Hier ist ein Beispielcode:

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

Dies funktionierte in SSMS:

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

Wenn Sie wissen, dass alle Daten nur ein einziges Wort sind, finden Sie hier eine Lösung. Aktualisieren Sie zuerst die Spalte auf alle unteren und führen Sie dann Folgendes aus

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

Vor kurzem musste ich mich darum kümmern und kam auf das Folgende, nachdem nichts alles getroffen hatte, was ich wollte. Dies wird einen ganzen Satz machen, Fälle für spezielle Wortbehandlung. Wir hatten auch Probleme mit Einzelzeichen-Wörtern, die viele der einfacheren Methoden handhaben, aber nicht die komplizierteren Methoden. Einzelne Rückgabevariable, auch keine Schleifen oder Cursor.

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

Kopieren Sie Ihre Daten, fügen Sie sie in MS Word ein und verwenden Sie die integrierte Textkonvertierung für "Großschreibung jedes Wortes". Vergleichen Sie mit Ihren Originaldaten, um Ausnahmen zu beheben. Ich kann keinen Weg umgehen, um Ausnahmen vom Typ "MacDonald" und "IBM" manuell zu umgehen, aber so habe ich es FWIW gemacht.