मारियाडीबी में अपरकेस अक्षरों वाली पंक्तियों को खोजने के 4 तरीके

मारियाडीबी में अपरकेस वर्णों वाली पंक्तियों को वापस करने के लिए यहां चार विकल्प दिए गए हैं।

नमूना डेटा

मान लीजिए हमारे पास निम्न डेटा वाली एक तालिका है:

SELECT c1 FROM t1;

परिणाम:

+----------------+
| c1             |
+----------------+
| CAFÉ           |
| Café           |
| café           |
| 1café          |
| eCafé          |
| James Bond 007 |
| JB 007         |
| 007            |
| NULL           |
|                |
| É              |
| É 123          |
| é              |
| é 123          |
| ø              |
| Ø              |
+----------------+

अपरकेस अक्षरों वाली पंक्तियों को वापस करने के लिए हम निम्नलिखित विधियों का उपयोग कर सकते हैं।

विकल्प 1:पॉज़िक्स कैरेक्टर क्लास से तुलना करें

हम REGEXP . का उपयोग कर सकते हैं एक नियमित अभिव्यक्ति पैटर्न का मिलान करने के लिए ऑपरेटर।

हमारे कॉलम की तुलना [:upper:] . से करना एक आसान विकल्प है पॉज़िक्स कैरेक्टर क्लास:

SELECT c1 FROM t1
WHERE c1 REGEXP '[[:upper:]]';

परिणाम:

+----------------+
| c1             |
+----------------+
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
| É              |
| É 123          |
| Ø              |
+----------------+

RLIKE REGEXP . का पर्याय है , इसलिए हम REGEXP . को बदल सकते हैं RLIKE . के साथ समान परिणाम प्राप्त करने के लिए:

SELECT c1 FROM t1
WHERE c1 RLIKE '[[:upper:]]';

विकल्प 2:LOWER() से तुलना करें स्ट्रिंग

एक अन्य विकल्प LOWER() . का उपयोग करना है मूल मान की तुलना इसके लोअरकेस समकक्ष से करने के लिए कार्य करता है:

SELECT c1 FROM t1
WHERE BINARY LOWER(c1) <> BINARY c1;

परिणाम:

+----------------+
| c1             |
+----------------+
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
| É              |
| É 123          |
| Ø              |
+----------------+

के बराबर नहीं का उपयोग करके (<> ) ऑपरेटर (आप वैकल्पिक रूप से != . का उपयोग कर सकते हैं इसके बजाय <> यदि आप चाहें), तो हम केवल उन्हीं पंक्तियों को लौटाते हैं जो उनके लोअरकेस समकक्षों से भिन्न होती हैं। हम ऐसा इसलिए करते हैं क्योंकि, यदि कोई मान इसके लोअरकेस समकक्ष के समान है, तो यह पहले से ही लोअरकेस था (और हम इसे वापस नहीं करना चाहते हैं)।

डिफ़ॉल्ट रूप से, मारियाडीबी केस-असंवेदनशील खोज करता है, और इसलिए मैं BINARY का उपयोग करता हूं केस-संवेदी खोज प्राप्त करने के लिए ऑपरेटर।

इसे इस तरह भी किया जा सकता है:

SELECT c1 FROM t1
WHERE BINARY(LOWER(c1)) <> BINARY(c1);

विकल्प 3:वास्तविक वर्णों से तुलना करें

एक अन्य विकल्प REGEXP . का उपयोग करना है एक नियमित अभिव्यक्ति पैटर्न वाला ऑपरेटर जिसमें स्पष्ट रूप से प्रत्येक अपरकेस वर्ण शामिल होता है जिसे हम मिलान करना चाहते हैं:

SELECT c1 FROM t1
WHERE BINARY c1 REGEXP BINARY '[ABCDEFGHIJKLMNOPQRSTUVWXYZ]';

परिणाम:

+----------------+
| c1             |
+----------------+
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
+----------------+

पिछले उदाहरणों की तुलना में इस बार कम पंक्तियाँ दी गई हैं। ऐसा इसलिए है क्योंकि मैंने जैसे É वर्ण निर्दिष्ट नहीं किए हैं और Ø , जो पिछले उदाहरण में लौटाए गए थे। हमारे परिणाम में É . शामिल है लेकिन वह पंक्ति केवल इसलिए लौटाई गई क्योंकि इसमें अन्य अपरकेस वर्ण भी शामिल हैं जो करते हैं मैच।

इसलिए, आपको यह सुनिश्चित करना होगा कि यदि आप इस विकल्प का उपयोग करते हैं तो आपके पास सभी मान्य वर्ण शामिल हैं।

विकल्प 4:वर्णों की श्रेणी से तुलना करें

ऐसा करने का दूसरा तरीका यह है कि हम उन वर्णों की श्रेणी निर्दिष्ट करें जिनका हम मिलान करना चाहते हैं:

SELECT c1 FROM t1
WHERE BINARY c1 REGEXP BINARY '[A-Z]';

परिणाम:

+----------------+
| c1             |
+----------------+
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
+----------------+