मारियाडीबी में बाइनरी ऑपरेटर कैसे काम करता है?

MariaDB में, BINARY ऑपरेटर इसके बाद वाली स्ट्रिंग को बाइनरी स्ट्रिंग में कास्ट करता है।

BINARY ऑपरेटर आपको चरित्र द्वारा चरित्र के बजाय बाइट द्वारा कॉलम तुलना बाइट करने में सक्षम बनाता है। इससे तुलना केस संवेदी हो जाती है, भले ही कॉलम को BINARY . के रूप में परिभाषित न किया गया हो या BLOB . इसका यह भी अर्थ है कि अग्रणी/पिछला स्थान महत्वपूर्ण हो जाते हैं।

उदाहरण

यहां एक सरल उदाहरण दिया गया है:

SELECT BINARY 'Cat';

परिणाम:

+--------------+
| BINARY 'Cat' |
+--------------+
| Cat          |
+--------------+

यह उदाहरण वास्तव में प्रदर्शित नहीं करता है कि कैसे BINARY ऑपरेटर स्ट्रिंग तुलना को प्रभावित कर सकता है। निम्नलिखित उदाहरण करते हैं।

अग्रणी/पिछला स्थान

जैसा कि उल्लेख किया गया है, बाइट द्वारा स्ट्रिंग्स बाइट की तुलना करते समय अग्रणी और अनुगामी रिक्त स्थान महत्वपूर्ण होते हैं (अर्थात BINARY के साथ) )।

सबसे पहले, यहां बिना किसी अग्रणी या पिछली जगह के एक स्ट्रिंग तुलना दी गई है:

SELECT 
    'Cat' = 'Cat',
    BINARY 'Cat' = 'Cat';

परिणाम:

+---------------+----------------------+
| 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' |
+---------------+----------------------+
|             1 |                    1 |
+---------------+----------------------+

चाहे हम BINARY . का उपयोग करें, हमें वही वापसी मूल्य मिलता है या नहीं।

लेकिन यहाँ क्या होता है जब हम किसी एक स्ट्रिंग में अनुगामी रिक्त स्थान जोड़ते हैं:

SELECT 
    'Cat' = 'Cat ',
    BINARY 'Cat' = 'Cat ',
    'Cat' = BINARY 'Cat ',
    BINARY 'Cat' = BINARY 'Cat ';

परिणाम:

+----------------+-----------------------+-----------------------+------------------------------+
| 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' |
+----------------+-----------------------+-----------------------+------------------------------+
|              1 |                     0 |                     0 |                            0 |
+----------------+-----------------------+-----------------------+------------------------------+

पहला वाला 1 लौटाता है जबकि अन्य (यानी BINARY . वाले वाले) ) वापसी 0 ।

बस यह सुनिश्चित करने के लिए, आइए उन स्ट्रिंग्स की तुलना करें जिनमें दोनों के पीछे के स्थान हैं:

SELECT
    'Cat ' = BINARY 'Cat ',
    BINARY 'Cat ' = BINARY 'Cat ';

परिणाम:

+------------------------+-------------------------------+
| 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' |
+------------------------+-------------------------------+
|                      1 |                             1 |
+------------------------+-------------------------------+

ध्यान रखें कि हम यहां केवल अग्रणी और पिछली जगहों के बारे में बात कर रहे हैं। यह अवधारणा एक स्ट्रिंग के बीच में रिक्त स्थान पर लागू नहीं होती है।

उदाहरण के लिए, एक स्ट्रिंग में दो रिक्त स्थान एक स्थान के बराबर नहीं हैं - यहां तक ​​कि BINARY का उपयोग किए बिना भी ऑपरेटर:

SELECT 'Homer Jay' = 'Homer  Jay';

परिणाम:

+----------------------------+
| 'Homer Jay' = 'Homer  Jay' |
+----------------------------+
|                          0 |
+----------------------------+

इस मामले में पहली स्ट्रिंग में एक स्थान होता है और दूसरे में दो रिक्त स्थान होते हैं। चरित्र तुलना के आधार पर चरित्र का उपयोग करते समय भी उनके लिए असमान होना पर्याप्त है।

केस संवेदनशीलता

BINARY ऑपरेटर केस संवेदी तुलना को बाध्य करता है, भले ही मिलान केस असंवेदनशील हो।

उदाहरण के लिए, यह मेरा कनेक्शन संयोजन है:

SELECT @@collation_connection;

परिणाम:

+------------------------+
| @@collation_connection |
+------------------------+
| utf8_general_ci        |
+------------------------+

ci अंत में मतलब केस असंवेदनशील ।

यहां अपरकेस बनाम लोअरकेस स्ट्रिंग्स की तुलना का एक उदाहरण दिया गया है:

SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT';

परिणाम:

+---------------+----------------------+
| 'cat' = 'CAT' | BINARY 'cat' = 'CAT' |
+---------------+----------------------+
|             1 |                    0 |
+---------------+----------------------+

पहली तुलना 1 लौटा, क्योंकि मेरा संयोजन केस असंवेदनशील है। दूसरा लौटा 0 , क्योंकि हम BINARY . का उपयोग करते हैं ऑपरेटर।

ऐसी स्ट्रिंग तुलनाओं के साथ आपको जो परिणाम मिलते हैं (बिना BINARY ऑपरेटर) आपके संयोजन पर निर्भर करेगा। केस सेंसिटिव कॉलेशन का उपयोग करने से वही परिणाम मिलेगा जो हमें BINARY . के साथ मिला था .

प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है:

SELECT 
    _latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
    _latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
    BINARY 'cat' = 'CAT';

परिणाम:

+------+------+----------------------+
| ci   | cs   | BINARY 'cat' = 'CAT' |
+------+------+----------------------+
|    1 |    0 |                    0 |
+------+------+----------------------+

यहां, मैंने स्ट्रिंग स्तर पर वर्ण सेट और संयोजन को स्पष्ट रूप से निर्दिष्ट किया है। ऐसा करने के लिए वाक्य रचना इस प्रकार है:

[_charset_name]'string' [COLLATE collation_name]

हम देख सकते हैं कि केस असंवेदनशील कॉलेशन ने केस सेंसिटिव कॉलेशन के लिए एक अलग परिणाम दिया। और केस सेंसिटिव कॉलेशन ने वही परिणाम दिया जो हमें BINARY . का उपयोग करते समय मिलता है ऑपरेटर।