मारियाडीबी में ओआरडी () कैसे काम करता है

मारियाडीबी में, ORD() एक अंतर्निहित स्ट्रिंग फ़ंक्शन है जो अपने स्ट्रिंग तर्क के सबसे बाएं वर्ण का संख्यात्मक वर्ण कोड देता है।

ORD() फ़ंक्शन मल्टी-बाइट वर्णों को संभाल सकता है। यह ASCII() . के विपरीत है फ़ंक्शन, जो केवल सिंगल-बाइट (8 बिट) वर्णों को संभालता है।

सिंटैक्स

वाक्य रचना इस प्रकार है:

ORD(str)

जहां str स्ट्रिंग तर्क है।

ORD() केवल बाईं ओर . का सांख्यिक कोड लौटाएगा इस स्ट्रिंग का चरित्र।

यदि सबसे बायां वर्ण एक बहु-बाइट वर्ण है, ORD() इसके परिणाम की गणना करने के लिए निम्न सूत्र का उपयोग करता है:

  (1st byte code)
+ (2nd byte code x 256)
+ (3rd byte code x 256 x 256) ...

उदाहरण

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

SELECT ORD('H');

परिणाम:

+----------+
| ORD('H') |
+----------+
|       72 |
+----------+

जैसा कि बताया गया है, ORD() केवल बाईं ओर . का कोड लौटाता है चरित्र। इसलिए, निम्नलिखित समान परिणाम देता है:

SELECT ORD('Homer');

परिणाम:

+--------------+
| ORD('Homer') |
+--------------+
|           72 |
+--------------+

इसे और अधिक प्रदर्शित करने के लिए, उपरोक्त स्ट्रिंग में प्रत्येक अक्षर से कोड प्राप्त करें:

SELECT 
    ORD('H'),
    ORD('o'),
    ORD('m'),
    ORD('e'),
    ORD('r');

परिणाम:

+----------+----------+----------+----------+----------+
| ORD('H') | ORD('o') | ORD('m') | ORD('e') | ORD('r') |
+----------+----------+----------+----------+----------+
|       72 |      111 |      109 |      101 |      114 |
+----------+----------+----------+----------+----------+

मल्टी-बाइट वर्ण

यहां एक उदाहरण दिया गया है जो बहु-बाइट वर्ण का उपयोग करता है:

SELECT ORD('©');

परिणाम:

+-----------+
| ORD('©')  |
+-----------+
|     49833 |
+-----------+

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

अपरकेस अक्षरों में उनके लोअरकेस समकक्षों के लिए एक अलग ASCII मान होता है।

उदाहरण:

SELECT 
    ORD('H'),
    ORD('h');

परिणाम:

+----------+----------+
| ORD('H') | ORD('h') |
+----------+----------+
|       72 |      104 |
+----------+----------+

एक डेटाबेस उदाहरण

यहां ORD() का उपयोग करने का एक उदाहरण दिया गया है डेटाबेस क्वेरी में:

USE PetHouse;
SELECT 
  PetName, 
  ORD(PetName) AS 'ASCII value of leftmost character'
FROM Pets;

परिणाम:

+---------+-----------------------------------+
| PetName | ASCII value of leftmost character |
+---------+-----------------------------------+
| Fluffy  |                                70 |
| Fetch   |                                70 |
| Scratch |                                83 |
| Wag     |                                87 |
| Tweet   |                                84 |
| Fluffy  |                                70 |
| Bark    |                                66 |
| Meow    |                                77 |
+---------+-----------------------------------+

सबसे सही चरित्र

यहाँ, मैं RIGHT() . का उपयोग करता हूँ प्रत्येक पालतू नाम से सबसे सही वर्ण वापस करने के लिए कार्य करें, और फिर ORD() के साथ इसका पुन:उपयोग करें उस चरित्र के लिए ASCII मान वापस करने के लिए कार्य करें।

USE PetHouse;
SELECT 
  PetName,
  RIGHT(PetName, 1) 'Rightmost character',
  ORD(RIGHT(PetName, 1)) 'ASCII code'
FROM Pets;

परिणाम:

+---------+---------------------+------------+
| PetName | Rightmost character | ASCII code |
+---------+---------------------+------------+
| Fluffy  | y                   |        121 |
| Fetch   | h                   |        104 |
| Scratch | h                   |        104 |
| Wag     | g                   |        103 |
| Tweet   | t                   |        116 |
| Fluffy  | y                   |        121 |
| Bark    | k                   |        107 |
| Meow    | w                   |        119 |
+---------+---------------------+------------+

खाली स्ट्रिंग्स

0 . में एक खाली स्ट्रिंग परिणाम प्रदान करना लौटाया जा रहा है।

SELECT ORD('');

परिणाम:

+---------+
| ORD('') |
+---------+
|       0 |
+---------+

शून्य मान

null प्रदान करना परिणाम null लौटाया जा रहा है।

SELECT ORD(null);

परिणाम:

+-----------+
| ORD(null) |
+-----------+
|      NULL |
+-----------+