मारियाडीबी GROUP_CONCAT ()

मारियाडीबी में एक GROUP_CONCAT() है फ़ंक्शन जो हमें एक क्वेरी से एक सीमांकित सूची के रूप में कॉलम वापस करने में सक्षम बनाता है।

सिंटैक्स

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

GROUP_CONCAT([DISTINCT] expr [,expr ...]
             [ORDER BY {unsigned_integer | col_name | expr}
                 [ASC | DESC] [,col_name ...]]
             [SEPARATOR str_val]
             [LIMIT {[offset,] row_count | row_count OFFSET offset}])

उदाहरण

मान लीजिए कि हम निम्नलिखित क्वेरी चलाते हैं:

SELECT PetName 
FROM Pets;

और हमें निम्नलिखित परिणाम मिलते हैं:

+---------+
| PetName |
+---------+
| Fluffy  |
| Fetch   |
| Scratch |
| Wag     |
| Tweet   |
| Fluffy  |
| Bark    |
| Meow    |
+---------+
8 rows in set (0.001 sec)

हम उपयोग कर सकते हैं GROUP_CONCAT() उन सभी पंक्तियों को एक सीमित सूची के रूप में वापस करने के लिए।

इसे प्राप्त करने के लिए, हमें केवल PetName . पास करना होगा GROUP_CONCAT() . के तर्क के रूप में कॉलम समारोह:

SELECT GROUP_CONCAT(PetName) 
FROM Pets;

परिणाम:

+-------------------------------------------------+
| GROUP_CONCAT(PetName)                           |
+-------------------------------------------------+
| Fluffy,Fetch,Scratch,Wag,Tweet,Fluffy,Bark,Meow |
+-------------------------------------------------+
1 row in set (0.003 sec)

आदेश देना

हम ORDER BY . का उपयोग कर सकते हैं इस फ़ंक्शन के आउटपुट को ऑर्डर करने के लिए क्लॉज:

SELECT GROUP_CONCAT(PetName ORDER BY PetName DESC)
FROM Pets;

परिणाम:

Wag,Tweet,Scratch,Meow,Fluffy,Fluffy,Fetch,Bark

ध्यान दें कि यह केवल GROUP_CONCAT() . के आउटपुट को सॉर्ट करता है फ़ंक्शन - यह SELECT . पर लागू किसी भी आदेश से पूरी तरह से स्वतंत्र है बयान ही।

आउटपुट सीमित करना

हम LIMIT . का उपयोग कर सकते हैं सूची में कितने आइटम शामिल हैं, इसे सीमित करने के लिए खंड:

SELECT GROUP_CONCAT(PetName LIMIT 3)
FROM Pets;

परिणाम:

Fluffy,Fetch,Scratch

कोई भी आदेश LIMIT . से पहले लागू किया जाता है खंड:

SELECT GROUP_CONCAT(PetName ORDER BY PetName DESC LIMIT 3)
FROM Pets;

परिणाम:

Wag,Tweet,Scratch

ध्यान दें कि LIMIT खंड केवल मारियाडीबी 10.3.3 से समर्थित है।

DISTINCT खंड

हम DISTINCT . का उपयोग कर सकते हैं अद्वितीय मान वापस करने के लिए खंड। दूसरे शब्दों में, यदि डुप्लिकेट मान हैं, तो केवल एक घटना वापस आती है:

SELECT GROUP_CONCAT(DISTINCT PetName ORDER BY PetName ASC)
FROM Pets;

परिणाम:

Bark,Fetch,Fluffy,Meow,Scratch,Tweet,Wag

इस मामले में, Fluffy केवल एक बार प्रकट होता है। जब हम इसे DISTINCT . के बिना चलाते हैं खंड, Fluffy दो बार प्रकट होता है।

विभाजक को बदलना

डिफ़ॉल्ट रूप से, सूची अल्पविराम का उपयोग सीमांकक के रूप में करती है। लेकिन अगर हम चाहें तो इसे बदल सकते हैं:

SELECT GROUP_CONCAT(PetName SEPARATOR '-')
FROM Pets;

परिणाम:

Fluffy-Fetch-Scratch-Wag-Tweet-Fluffy-Bark-Meow

हम सभी विभाजकों को हटाने के लिए एक खाली स्ट्रिंग का भी उपयोग कर सकते हैं (ताकि मानों को जोड़ा जा सके):

SELECT GROUP_CONCAT(PetName SEPARATOR '')
FROM Pets;

और हमें निम्नलिखित परिणाम मिलते हैं:

FluffyFetchScratchWagTweetFluffyBarkMeow

समूहीकृत क्वेरी परिणाम

हम GROUP_CONCAT() . शामिल कर सकते हैं GROUP BY . के साथ एक क्वेरी में इस तरह का परिणाम प्राप्त करने के लिए क्लॉज:

SELECT 
    PetTypeId,
    GROUP_CONCAT(PetName ORDER BY PetName ASC)
FROM Pets
GROUP BY PetTypeId
ORDER BY PetTypeId;

परिणाम:

+-----------+--------------------------------------------+
| PetTypeId | GROUP_CONCAT(PetName ORDER BY PetName ASC) |
+-----------+--------------------------------------------+
|         1 | Tweet                                      |
|         2 | Fluffy,Meow,Scratch                        |
|         3 | Bark,Fetch,Fluffy,Wag                      |
+-----------+--------------------------------------------+

मेरे डेटाबेस में, वास्तविक पालतू प्रकार के नाम PetTypes . नामक एक अन्य तालिका में हैं . इसलिए हम एक INNER JOIN चला सकते हैं PetTypes पर वास्तविक पालतू प्रकार के नाम प्राप्त करने के लिए तालिका:

SELECT 
    pt.PetType,
    GROUP_CONCAT(p.PetName ORDER BY p.PetName ASC)
FROM Pets p
INNER JOIN PetTypes pt ON
p.PetTypeId = pt.PetTypeId
GROUP BY pt.PetType
ORDER BY pt.PetType ASC;

परिणाम:

+---------+------------------------------------------------+
| PetType | GROUP_CONCAT(p.PetName ORDER BY p.PetName ASC) |
+---------+------------------------------------------------+
| Bird    | Tweet                                          |
| Cat     | Fluffy,Meow,Scratch                            |
| Dog     | Bark,Fetch,Fluffy,Wag                          |
+---------+------------------------------------------------+

लंबाई की सीमाएं

बाइट्स में दी गई अधिकतम लंबाई group_concat_max_len . द्वारा निर्धारित की जाती है सर्वर सिस्टम वेरिएबल, जो डिफ़ॉल्ट रूप से 1M (MariaDB 10.2.4 और उच्चतर में) या 1K (MariaDB 10.2.3 और निम्न में) है। अगर group_concat_max_len है 512 या उससे कम, वापसी का प्रकार VARBINARY . है या VARCHAR; अन्यथा, वापसी प्रकार BLOB है या TEXT . बाइनरी या गैर-बाइनरी प्रकारों के बीच चुनाव इनपुट पर निर्भर करता है।

आप इस तरह वर्तमान मूल्य की जांच कर सकते हैं:

SHOW VARIABLES LIKE '%group_concat%';

इस मान को बदलने का सिंटैक्स इस प्रकार है:

SET [GLOBAL | SESSION] group_concat_max_len = val;

जहां val एक अहस्ताक्षरित पूर्णांक है।