SQL सर्वर में अपरकेस अक्षरों वाली पंक्तियों को वापस करने के लिए नीचे पाँच विकल्प दिए गए हैं।
नमूना डेटा
मान लीजिए हमारे पास निम्न डेटा वाली एक तालिका है:
SELECT c1 FROM t1;परिणाम:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | café | | 1café | | eCafé | | James Bond 007 | | JB 007 | | 007 | | NULL | | | | É | | É 123 | | é | | é 123 | | ø | | Ø | +----------------+
अपरकेस अक्षरों वाली पंक्तियों को वापस करने के लिए हम निम्नलिखित विधियों का उपयोग कर सकते हैं।
विकल्प 1:LOWER() से तुलना करें स्ट्रिंग
हम LOWER() . का उपयोग कर सकते हैं मूल मान की तुलना इसके लोअरकेस समकक्ष से करने के लिए कार्य करता है:
SELECT c1 FROM t1
WHERE LOWER(c1) COLLATE Latin1_General_CS_AS <> c1;परिणाम:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | | É | | É 123 | | Ø | +----------------+
के बराबर नहीं का उपयोग करके (<> ) ऑपरेटर (आप वैकल्पिक रूप से उपयोग कर सकते हैं != के बजाय <> यदि आप चाहें), तो हम केवल उन्हीं पंक्तियों को लौटाते हैं जो उनके लोअरकेस समकक्षों से भिन्न होती हैं। हम ऐसा इसलिए करते हैं क्योंकि, यदि कोई मान इसके लोअरकेस समकक्ष के समान है, तो यह पहले से ही लोअरकेस था (और हम इसे वापस नहीं करना चाहते हैं)।
हम COLLATE Latin1_General_CS_AS . का भी उपयोग करते हैं केस-संवेदी (और उच्चारण-संवेदनशील) संयोजन को स्पष्ट रूप से निर्दिष्ट करने के लिए। इसके बिना, आपके सिस्टम पर उपयोग किए जा रहे संयोजन के आधार पर, आपको अप्रत्याशित परिणाम मिल सकते हैं।
विकल्प 2:वास्तविक वर्णों से तुलना करें
एक अन्य विकल्प LIKE . का उपयोग करना है ऑपरेटर और वास्तविक अपरकेस वर्ण निर्दिष्ट करें जिनका हम मिलान करना चाहते हैं:
SELECT c1 FROM t1
WHERE c1 LIKE '%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%'
COLLATE Latin1_General_CS_AS;परिणाम:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
इस मामले में, पिछले उदाहरण की तुलना में कम पंक्तियाँ दी जाती हैं। ऐसा इसलिए है क्योंकि मैंने É . जैसे वर्ण निर्दिष्ट नहीं किए हैं और Ø , जो पिछले उदाहरण में लौटाए गए थे। हमारे परिणाम में É . शामिल है लेकिन वह पंक्ति केवल इसलिए लौटाई गई क्योंकि इसमें अन्य अपरकेस वर्ण भी शामिल हैं जो करते हैं मैच।
इसलिए, यह विकल्प पिछले वाले की तुलना में अधिक सीमित है, लेकिन यह आपको उन पात्रों पर अधिक नियंत्रण प्रदान करता है, जिनका आप मिलान करना चाहते हैं।
विकल्प 3:वर्णों की श्रेणी से तुलना करें
हम वैकल्पिक रूप से उन वर्णों की श्रेणी निर्दिष्ट कर सकते हैं जिनका हम मिलान करना चाहते हैं:
SELECT * FROM t1
WHERE c1 LIKE '%[A-Z]%'
COLLATE Latin1_General_100_BIN2;परिणाम:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
इस मामले में, मैंने एक द्विआधारी संयोजन का उपयोग किया (Latin1_General_100_BIN2 ) मैंने ऐसा इसलिए किया क्योंकि बाइनरी कॉलेशन प्रत्येक मामले को अलग-अलग क्रमबद्ध करते हैं (जैसे:AB....YZ...ab...yz )।
अन्य कॉलेशन अपरकेस और लोअरकेस अक्षरों को आपस में मिलाते हैं (जैसे:AaBb...YyZz ), जो इसलिए अपरकेस और लोअरकेस दोनों वर्णों से मेल खाएगा।
विकल्प 4:अपरकेस कैरेक्टर का पहला इंस्टेंस ढूंढें
इसे करने का दूसरा तरीका PATINDEX() . का उपयोग करना है समारोह:
SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 0;परिणाम:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
इस उदाहरण में, हम सटीक वर्णों को निर्दिष्ट करते हैं जिनका हम मिलान करना चाहते हैं, और इसलिए इस उदाहरण में, हमें वर्णों वाली पंक्तियाँ नहीं मिलीं like É और Ø (उसके अलावा जिसमें अन्य वर्ण भी शामिल हैं जिनका मिलान किया गया था)।
इस तकनीक का एक लाभ यह है कि यदि हम चाहें तो पहले वर्ण (या वर्णों की निर्दिष्ट संख्या) को अनदेखा करने के लिए हम इसका उपयोग कर सकते हैं:
SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 1;परिणाम:
Time: 0.472s +-------+ | c1 | |-------| | eCafé | +-------+
इसलिए, हम उन सभी पंक्तियों को वापस कर सकते हैं जिनमें अपरकेस वर्ण हैं, लेकिन जहां पहला वर्ण अपरकेस नहीं है।
ऐसा इसलिए है क्योंकि PATINDEX() पैटर्न की पहली घटना की प्रारंभिक स्थिति देता है (हमारे मामले में, पैटर्न अपरकेस वर्णों की एक सूची है)। यदि पहली घटना की प्रारंभिक स्थिति 1 से अधिक है, तो पहला वर्ण हमारी अपरकेस वर्णों की सूची में नहीं है।
विकल्प 5:श्रेणी के आधार पर पहला उदाहरण खोजें
हम PATINDEX() . का भी उपयोग कर सकते हैं एक सीमा के साथ:
SELECT * FROM t1
WHERE PATINDEX('%[A-Z]%', c1
COLLATE Latin1_General_100_BIN2) > 1;परिणाम:
+-------+ | c1 | |-------| | eCafé | +-------+
मैंने फिर से एक द्विआधारी संयोजन का उपयोग किया (जैसे अन्य श्रेणी उदाहरण के साथ)।
