SQL सर्वर में प्रत्येक वाक्य के प्रत्येक शब्द के केवल पहले अक्षर को कैपिटलाइज़ करें


18

मैं एसक्यूएल कॉलम में प्रत्येक वाक्य के प्रत्येक शब्द के केवल पहले अक्षर को कैपिटल करना चाहता हूं।

उदाहरण के लिए, यदि वाक्य है:

'मुझे फिल्में पसंद हैं'

फिर मुझे आउटपुट चाहिए:

'आई लाइक मूवीज'

प्रश्न:

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]

यहाँ मैंने ऊपरी, निचला और पहला अक्षर केवल अपने कॉलम में रखा (यहाँ मैंने एक यादृच्छिक शब्द रखा)।

यहाँ मेरे परिणाम हैं:

यहाँ छवि विवरण दर्ज करें

क्या ऐसा करने की कोई संभावना है?

उपयोगकर्ता परिभाषित फ़ंक्शन का उपयोग किए बिना परिणाम प्राप्त करने की कोई संभावनाएं?

मुझे आउटपुट चाहिए Qwerty Keyboard


11
आप sql सर्वर के भीतर ऐसा क्यों करना चाहते हैं? आपकी प्रस्तुति की परत को कुशलता से संभालना चाहिए!
परिजन शाह

आपके पास हमेशा एक प्रस्तुति परत नहीं होती है, जैसे कि SQL सर्वर में आयात किए गए खराब डेटा को साफ करते समय, और आप ऐसा करने के लिए C # प्रोग्राम नहीं लिखना चाहते हैं। हां, आप सीएलआर फ़ंक्शन में निवेश कर सकते हैं, लेकिन यह कैसे काम करता है कि कुछ त्वरित और गंदा है।
जेफरी रफगार्डन

जवाबों:


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

यह पहले रिक्त स्थान के साथ सभी स्थानों को बदलकर स्ट्रिंग को XML में परिवर्तित करता है <X/>। फिर यह एक्सएमएल को एक शब्द प्रति पंक्ति का उपयोग करने के लिए श्रेड करता है nodes()। पंक्तियों को एक मान पर वापस लाने के लिए यह for xml pathचाल का उपयोग करता है ।


8
और वह कोड ठीक यही कारण है कि मैं एसक्यूएल में ऐसा कभी नहीं करूंगा। जवाब गलत नहीं है - यह कहा गया था। लेकिन मानक SQL इस प्रकार के स्ट्रिंग हेरफेर के लिए हास्यास्पद रूप से बीमार है। एक CLR आधारित फ़ंक्शन काम करेगा, या बस इसे प्रस्तुति परत पर कर देगा।
टॉमटॉम

8
@TomTom यह जटिल दिखता है, लेकिन यह उस क्वेरी प्लान की तुलना में कुछ भी नहीं है जो इसे पैदा करता है और यह किसी भी मानक से तेज नहीं होगा। यह वास्तव में शैक्षिक और मजेदार है कि वास्तव में क्वेरी में क्यों चल रहा है और इसे जिस तरह से लिखा गया है, उसे खोदना है। समस्या को स्ट्रिंग विभाजन फ़ंक्शन (संख्या तालिका) के साथ हल किया जा सकता है। संगति के लिए for xml pathचाल से बचने के लिए मुश्किल । जब तक आप सीएलआर के लिए नहीं जाते हैं जो सबसे अच्छा विकल्प होगा यदि गति और दक्षता महत्वपूर्ण है।
मिकेल एरिकसन

15

SQL Server 2016 में आप इसे R, जैसे के साथ कर सकते हैं

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

आपको एक अलग सवाल करना चाहिए या नहीं:)


ओह, आपको निश्चित रूप से नहीं करना चाहिए। कभी-कभी यह सबसे कम बुरा विकल्प होता है, या जैसा कि ओपी ने उल्लेख किया है, उन्हें एक त्वरित और गंदे की आवश्यकता है।
जोनाथन फाइट

13

हो सकता है कि मैं मूर्खतापूर्ण हूं लेकिन नीचे दिए गए क्वेरी की जांच कर रहा हूं कि मैंने कुछ प्रदान किया है, यह थोड़ा अधिक कुशल (अनुक्रमण पर निर्भर करता है) लगता है।

कोड थोड़ा बेवकूफ है, लेकिन यह कहावत नहीं है कि अगर यह बेवकूफ दिखता है, लेकिन यह काम करता है तो यह बेवकूफ नहीं है।

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

2
यह एक महान और भयानक, उत्तर है। मैं विशेष रूप से उस स्थान को पसंद करता हूं जो आपने शुरुआत में किया है और फिर अंत में स्ट्रिप कर दिया।
ब्रैड

2
@BradC यह घृणित है, लेकिन जब मैंने इसे XML विधि की तुलना में कोशिश की है, तो डेटा के मुकाबले यह लागत के एक अंश पर चलता है!
क्रिस जे

हम जो कुछ भी मानते हैं उसके बारे में अजीब और ईमानदारी के लिए +1 अच्छा है। हमें शायद ध्यान देना चाहिए, कि यह डिबग करना और बनाए रखना कठिन है, लेकिन बहुत संकीर्ण और कभी बदलती आवश्यकताओं के साथ "एक चल रहे सिस्टम को कभी नहीं छूएं", यह सिर्फ ऊपर उठने के योग्य है क्योंकि इसे संदर्भ में पढ़ना होगा।
कैसर

9

एक अन्य विकल्प SQLCLR के माध्यम से इसे संभालना है। .NET में पहले से ही एक विधि उपलब्ध है जो ऐसा करती है: TextInfo.ToTitleCase (इन System.Globalization)। यह विधि प्रत्येक शब्द के पहले अक्षर को अपर-केस करेगी, और शेष अक्षरों को लोअर-केस। यहां अन्य प्रस्तावों के विपरीत, यह उन शब्दों को भी छोड़ देता है, जो सभी ऊपरी मामलों में हैं, उन्हें समरूप मानते हैं। बेशक, यदि यह व्यवहार वांछित है, तो ऐसा करने के लिए किसी भी टी-एसक्यूएल सुझाव को अपडेट करना काफी आसान होगा।

.NET पद्धति का एक लाभ यह है कि यह अपर-केस अक्षर हैं जो अनुपूरक वर्ण हैं। उदाहरण के लिए: DESERET SMALL LETTER OW में DESERET CAPITAL LETTER OW का ऊपरी-मामला मानचित्रण है (दोनों जब मैं यहां चिपकाता हूं तो बक्से के रूप में दिखाई देता है) , लेकिन UPPER()फ़ंक्शन लोअर-केस संस्करण को ऊपरी-केस में नहीं बदलता है, तब भी वर्तमान डेटाबेस के लिए डिफ़ॉल्ट Collation सेट है Latin1_General_100_CI_AS_SC। यह MSDN प्रलेखन के साथ संगत लगता है जो सूचीबद्ध नहीं करता है UPPERऔर LOWERफ़ंक्शन के चार्ट में जो एक _SCCollation का उपयोग करते समय अलग तरीके से व्यवहार करते हैं : Collation और यूनिकोड समर्थन: अनुपूरक वर्ण

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]

रिटर्न (बढ़े हुए आप वास्तव में अनुपूरक चरित्र देख सकते हैं):

UPPER () अनुपूरक चरित्र के साथ काम नहीं करते हुए क्वेरी परिणाम

आप निम्न-वर्णों की पूरी (और वर्तमान) सूची देख सकते हैं, जो कि यूनिकोड.ऑर्ग पर निम्न खोज सुविधा का उपयोग करके अपर-केस में बदल जाती हैं (जब तक आप "DESERET" प्राप्त नहीं कर लेते, आप नीचे स्क्रॉल करके अनुपूरक वर्ण देख सकते हैं) अनुभाग, या बस हिट Control-Fऔर उस शब्द के लिए खोज):

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

हालांकि ईमानदार होने के लिए, यह बहुत बड़ा लाभ नहीं है क्योंकि यह संदिग्ध है कि कोई भी वास्तव में पूरक वर्णों में से किसी का उपयोग कर रहा है जो शीर्षक-आवरण हो सकता है। किसी भी तरह से, यहाँ 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));
    }
}

यहाँ @ MikaelEriksson का सुझाव है - NVARCHARडेटा को संभालने के लिए थोड़ा संशोधित किया गया है और साथ ही उन शब्दों को छोड़ें जो सभी ऊपरी मामले हैं (.NET विधि के व्यवहार के अधिक निकटता से मेल खाते हैं) - साथ ही उस टी-एसक्यूएल कार्यान्वयन का परीक्षण और 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) -- D  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];

SQL SQL के माध्यम से T-SQL XML कोड और ToTitleCase का आउटपुट दिखा क्वेरी परिणाम

व्यवहार में एक और अंतर यह है कि यह विशेष टी-एसक्यूएल कार्यान्वयन केवल रिक्त स्थान पर विभाजित होता है, जबकि ToTitleCase()विधि शब्द गैर-अक्षर को शब्द विभाजक मानता है (इसलिए "एक और दो" भाग से निपटने में अंतर)।

दोनों कार्यान्वयन अनुक्रमों के संयोजन को सही ढंग से संभालते हैं। "Üv thelA" में उच्चारण अक्षरों में से प्रत्येक में एक आधार पत्र और एक संयोजन डायअरेसिस / umlaut (प्रत्येक अक्षर के ऊपर दो बिंदु) शामिल हैं, और वे दोनों परीक्षणों में अन्य मामले में सही रूप से परिवर्तित होते हैं।

अंत में, SQLCLR संस्करण के लिए एक अप्रत्याशित नुकसान यह है कि विभिन्न परीक्षणों के साथ आने पर, मुझे .NET कोड में एक बग मिला है, जो सर्कुलेटेड लेटर्स से निपटने से संबंधित है (जो अब Microsoft कनेक्ट - UPDATE को सूचित किया गया है: कनेक्ट किया गया है। स्थानांतरित करने के लिए /dev/null- वस्तुतः - तो मुझे इसे फिर से जमा करने की आवश्यकता हो सकती है यदि समस्या अभी भी मौजूद है)। .NET लाइब्रेरी सर्किल लेटर्स को शब्द विभाजक के रूप में मानती है, यही कारण है कि इसे "ⓐDD" को ""d" में नहीं बदलना चाहिए जैसा कि इसे करना चाहिए।


FYI करें

TextInfo.ToTitleCaseउपर्युक्त विधि को एनक्लोज करने वाला एक पूर्व-निर्मित SQLCLR फ़ंक्शन अब SQL # (जो मैंने लिखा था) String_ToTitleCase और String_ToTitleCase4k के फ्री संस्करण में उपलब्ध है ।

😺


5

Mikael Eriksson के उत्तर के विकल्प के रूप में , आप बहु-पंक्ति चयन कथनों में चर सेटिंग के मालिकाना T-SQL हैंडलिंग का उपयोग करने पर विचार कर सकते हैं।

SQL सर्वर में, जब एक चर को SELECT स्टेटमेंट के हिस्से के रूप में सेट किया जा रहा है, तो प्रत्येक पंक्ति सेट लॉजिक के पुनरावृत्ति को निष्पादित करेगी।

फोल्क्स अक्सर इस विधि का उपयोग स्ट्रिंग्स को सुगम बनाने के लिए करते हैं, हालांकि यह असमर्थित है और इसके साथ कुछ आधिकारिक रूप से प्रलेखित मुद्दे हैं । आधिकारिक समस्या विशेष रूप से ORDER BY विशेषताओं से संबंधित है, और हमें यहां इसकी आवश्यकता नहीं है, इसलिए शायद यह एक सुरक्षित विकल्प है।

यहां, हम वर्णमाला के 26 अक्षरों पर पुनरावृत्ति करते हैं और उन्हें एक ऊपरी केस संस्करण के साथ प्रतिस्थापित करते हैं यदि वे एक स्थान से पहले हैं। (हम पहले अक्षर को कैपिटल करके और बाकी लोअर केस बनाकर शुरू में स्ट्रिंग करते हैं, जैसा कि आपने अपने प्रश्न में किया था।)

एसक्यूएल थोड़ा जटिल है क्योंकि इसे टैली टेबल - संख्याओं की एक तालिका के उपयोग की आवश्यकता होती है - जो कि यह कर रही है के 26 पुनरावृत्तियों को उत्पन्न करने के लिए। आप उस तालिका का निर्माण करने के लिए एक आसान इनलाइन टेबल-वैल्यू उपयोगकर्ता परिभाषित फ़ंक्शन (TVF) बना सकते हैं या आप एक भौतिक तालिका का उपयोग भी कर सकते हैं।

इस विकल्प का एक दोष यह है कि यह एक इनलाइन TVF का हिस्सा नहीं हो सकता क्योंकि इसमें एक चर सेट करना शामिल है। इसलिए यदि आप इस विधि को अपने आउटपुट के कॉलम में लागू करना चाहते हैं, तो आपको इसे मल्टी-स्टेटमेंट TVF या एक स्केलर यूज़र डिफाइन्ड फंक्शन में लपेटना होगा।

हालाँकि, इसकी क्वेरी योजना बहुत सरल है और यह शायद XML विधि की तुलना में काफी तेज है। आप तर्क कर सकते हैं कि यह समझना आसान है, भी (विशेषकर यदि आपके पास अपनी खुद की टेबल है)।

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

(मैंने इसे बहुत बड़े स्ट्रिंग का उपयोग करके परीक्षण किया और यह XML समाधान के लिए लगभग 6ms बनाम 14ms था।)

इस समाधान के साथ कई अतिरिक्त सीमाएं हैं। जैसा कि लिखा गया है, यह एक मामले को असंवेदनशील टकराव मानता है, हालांकि आप कुछ प्रदर्शन की कीमत पर, खोज शब्द पर एक कोलाज को निर्दिष्ट करके या LCASE चलाकर उस मुद्दे को समाप्त कर सकते हैं । यह केवल मानक ASCII पत्रों को संबोधित करता है और चरित्र सेट में उनके स्थान पर निर्भर करता है , इसलिए यह ñ के साथ कुछ भी नहीं करेगा।


3

यह मानते हुए कि आप केवल एक स्थान का अनुसरण करते हुए शब्दों को भुनाना चाहते हैं, यहाँ एक और तरीका है जिससे आप इसे कर सकते हैं।

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)

1

बुलेट प्रूफ नहीं हो सकता है, लेकिन मुझे आशा है कि यह इस धागे के लिए एक उपयोगी योगदान है।

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

0

नीचे मैं ऐसा करने के लिए एक Firebird डेटाबेस में प्रयोग की जाने वाली प्रक्रिया है। शायद बहुत सफाई की जा सकती है लेकिन यह मेरे लिए काम कर गया।

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

0

रिकर्सिव CTE इस तरह की चीजों के लिए काफी अच्छे हैं।

संभवतः बड़े ऑपरेशन के लिए विशेष रूप से कुशल नहीं है, लेकिन शुद्ध SQL चयन कथन में इस तरह के ऑपरेशन की अनुमति देता है:

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

आउटपुट:

The Quick Brown Fox Jumps   Over The Lazy Dog

0

मुझे यह संस्करण पसंद है। यह सरल है, और इसका उपयोग फंक्शन बनाने के लिए किया जा सकता है, बस आपके पास SQL ​​सर्वर का सही संस्करण होना चाहिए:

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

कौन सा सही संस्करण है?
dezso

SQL सर्वर (2016 से शुरू)
क्रिस्टी

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

मुझे उम्मीद है कि मदद मिलेगी ...


डेटाबेस व्यवस्थापकों में आपका स्वागत है! कृपया बताएं कि आपकी क्वेरी लेखक की समस्या को कैसे हल करती है; स्पष्टीकरण के बिना उत्तर आम तौर पर अच्छी तरह से प्राप्त नहीं होते हैं।
ग्लोरफाइंडेल

-3

परीक्षण डेटा

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

कार्यान्वयन

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

जो शब्द पहले से अलग हैं उन्हें कैपिटलाइज़ करना आसान है। मेरा मानना ​​है कि ओपी को एक स्ट्रिंग के भीतर शब्दों को कैसे पहचानना है, और उनमें से प्रत्येक को कैपिटलाइज़ करना है।
जॉन ऑफ ऑल ट्रेड्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.