यदि आपको SQL सर्वर में लोअरकेस अक्षरों वाली पंक्तियों को खोजने की आवश्यकता है, तो आप निम्न विकल्पों में से किसी एक को आज़मा सकते हैं।
नमूना डेटा
मान लीजिए हमारे पास निम्न डेटा वाली एक तालिका है:
SELECT c1 FROM t1;परिणाम:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | café | | 1café | | eCafé | | James Bond 007 | | JB 007 | | 007 | | NULL | | | | É | | É 123 | | é | | é 123 | | ø | | Ø | +----------------+
लोअरकेस अक्षरों वाली पंक्तियों को वापस करने के लिए हम निम्न विधियों का उपयोग कर सकते हैं।
विकल्प 1:UPPER() से तुलना करें स्ट्रिंग
हम UPPER() . का उपयोग कर सकते हैं मूल मान की तुलना इसके अपरकेस समकक्ष से करने के लिए कार्य करता है:
SELECT * FROM t1
WHERE UPPER(c1) COLLATE Latin1_General_CS_AS <> c1;परिणाम:
+----------------+ | c1 | |----------------| | Café | | café | | 1café | | eCafé | | James Bond 007 | | é | | é 123 | | ø | +----------------+
के बराबर नहीं का उपयोग करके (<> ) ऑपरेटर (आप वैकल्पिक रूप से != का उपयोग कर सकते हैं के बजाय <> यदि आप पसंद करते हैं), तो हम केवल उन पंक्तियों को लौटाते हैं जो उनके अपरकेस समकक्षों से भिन्न होती हैं। हम ऐसा इसलिए करते हैं क्योंकि, यदि कोई मान इसके अपरकेस समकक्ष के समान है, तो यह पहले से ही अपरकेस था (और हम इसे वापस नहीं करना चाहते हैं)।
हम COLLATE Latin1_General_CS_AS . का भी उपयोग करते हैं केस-संवेदी (और उच्चारण-संवेदनशील) संयोजन को स्पष्ट रूप से निर्दिष्ट करने के लिए। इसके बिना, आपके सिस्टम पर उपयोग किए जा रहे संयोजन के आधार पर, आपको अप्रत्याशित परिणाम मिल सकते हैं।
विकल्प 2:वास्तविक वर्णों से तुलना करें
हम वैकल्पिक रूप से LIKE . का उपयोग कर सकते हैं ऑपरेटर, और वास्तविक लोअरकेस वर्ण निर्दिष्ट करें जिनका हम मिलान करना चाहते हैं:
SELECT * FROM t1
WHERE c1 LIKE '%[abcdefghijklmnopqrstuvwxyz]%'
COLLATE Latin1_General_CS_AS;परिणाम:
+----------------+ | c1 | |----------------| | Café | | café | | 1café | | eCafé | | James Bond 007 | +----------------+
इस मामले में, पिछले उदाहरण की तुलना में कम पंक्तियाँ दी जाती हैं। ऐसा इसलिए है क्योंकि मैंने é . जैसे वर्ण निर्दिष्ट नहीं किए हैं और ø , जो पिछले उदाहरण में लौटाए गए थे। हालांकि एक पंक्ति में é . होता है , वह पंक्ति केवल इसलिए लौटाई गई क्योंकि इसमें अन्य लोअरकेस वर्ण भी शामिल हैं जो मेल खाते हैं।
इसलिए, यह उदाहरण पिछले वाले की तुलना में अधिक सीमित है, लेकिन यह आपको उन पात्रों पर अधिक नियंत्रण प्रदान करता है जिनका आप मिलान करना चाहते हैं।
विकल्प 3:वर्णों की श्रेणी से तुलना करें
हम वैकल्पिक रूप से उन वर्णों की श्रेणी निर्दिष्ट कर सकते हैं जिनका हम मिलान करना चाहते हैं:
SELECT * FROM t1
WHERE c1 LIKE '%[a-z]%'
COLLATE Latin1_General_100_BIN2;परिणाम:
+----------------+ | c1 | |----------------| | Café | | café | | 1café | | eCafé | | James Bond 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é | | 1café | | eCafé | | James Bond 007 | +----------------+
इस उदाहरण में, हम उन सटीक वर्णों को निर्दिष्ट करते हैं जिनका हम मिलान करना चाहते हैं, और इसलिए इस उदाहरण में, हमें अक्षर जैसे é वाली पंक्तियां नहीं मिलीं। और ø (उसके अलावा जिसमें अन्य वर्ण भी शामिल हैं जिनका मिलान किया गया था)।
इस तकनीक का एक लाभ यह है कि यदि हम चाहें तो पहले वर्ण (या वर्णों की निर्दिष्ट संख्या) को अनदेखा करने के लिए हम इसका उपयोग कर सकते हैं:
SELECT * FROM t1
WHERE PATINDEX('%[abcdefghijklmnopqrstuvwxyz]%', c1
COLLATE Latin1_General_CS_AS) > 1;परिणाम:
+----------------+ | c1 | |----------------| | Café | | 1café | | James Bond 007 | +----------------+
इसलिए, हम उन सभी पंक्तियों को वापस कर सकते हैं जिनमें लोअरकेस वर्ण हैं, लेकिन जहां पहला वर्ण लोअरकेस नहीं है।
ऐसा इसलिए है क्योंकि PATINDEX() पैटर्न की पहली घटना की प्रारंभिक स्थिति देता है (हमारे मामले में, पैटर्न लोअरकेस वर्णों की एक सूची है)। यदि पहली घटना की प्रारंभिक स्थिति 1 से अधिक है, तो पहला वर्ण हमारी लोअरकेस वर्णों की सूची में नहीं है।
हालांकि इस तकनीक का उपयोग पहले अक्षर के अपरकेस होने की उपेक्षा करने के लिए किया जा सकता है, लेकिन यह इस बात से इंकार नहीं करता है कि पहला वर्ण कोई अन्य वर्ण हो सकता है, जैसे कोई संख्या। हम इसे दूसरी पंक्ति में देख सकते हैं, जिसमें 1café . है ।
विकल्प 5:श्रेणी के आधार पर पहला उदाहरण खोजें
हम PATINDEX() . का भी उपयोग कर सकते हैं एक सीमा के साथ:
SELECT * FROM t1
WHERE PATINDEX('%[a-z]%', c1
COLLATE Latin1_General_100_BIN2) > 1;परिणाम:
+----------------+ | c1 | |----------------| | Café | | 1café | | James Bond 007 | +----------------+
मैंने फिर से एक द्विआधारी संयोजन का उपयोग किया (जैसे अन्य श्रेणी उदाहरण के साथ)।
