STRING_AGG () PostgreSQL में फ़ंक्शन

PostgreSQL में, हम STRING_AGG() . का उपयोग कर सकते हैं क्वेरी से कॉलम को सीमांकित सूची के रूप में वापस करने के लिए कार्य करता है।

सिंटैक्स

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

string_agg ( value text, delimiter text ) → text
string_agg ( value bytea, delimiter bytea ) → bytea

हम ORDER BY . का भी उपयोग कर सकते हैं खंड और एक DISTINCT इस फ़ंक्शन के भीतर से क्लॉज, जो फ़ंक्शन से आउटपुट को प्रभावित करता है। इस पर और नीचे।

उदाहरण

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

SELECT PetName 
FROM Pets;

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

+---------+
| petname |
+---------+
| Fluffy  |
| Fetch   |
| Scratch |
| Wag     |
| Tweet   |
| Fluffy  |
| Bark    |
| Meow    |
+---------+
(8 rows)

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

ऐसा करने के लिए, PetName पास करें पहले तर्क के रूप में कॉलम, और दूसरे तर्क के रूप में हमारे चुने हुए सीमांकक:

SELECT STRING_AGG(PetName, ',') 
FROM Pets;

परिणाम:

+-------------------------------------------------+
|                   string_agg                    |
+-------------------------------------------------+
| Fluffy,Fetch,Scratch,Wag,Tweet,Fluffy,Bark,Meow |
+-------------------------------------------------+
(1 row)

सीमांकक बदलना

पिछले उदाहरण में, मैंने अल्पविराम को सीमांकक के रूप में चुना था। यहाँ यह एक अलग सीमांकक के साथ है:

SELECT STRING_AGG(PetName, '-') 
FROM Pets;

परिणाम:

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

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

SELECT STRING_AGG(PetName, '') 
FROM Pets;

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

FluffyFetchScratchWagTweetFluffyBarkMeow

आदेश देना

हम ORDER BY . का उपयोग कर सकते हैं STRING_AGG() . के भीतर क्लॉज अपने स्वयं के आउटपुट को ऑर्डर करने के लिए कार्य करता है:

SELECT STRING_AGG(PetName, ',' ORDER BY PetName ASC) FROM Pets;

परिणाम:

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

वह आरोही क्रम में था।

यहाँ यह अवरोही क्रम में है:

SELECT STRING_AGG(PetName, ',' ORDER BY PetName DESC) FROM Pets;

परिणाम:

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

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

DISTINCT खंड

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

SELECT STRING_AGG(DISTINCT PetName, ',' ORDER BY PetName ASC) FROM Pets;

परिणाम:

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

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

SELECT STRING_AGG(PetName, ',' ORDER BY PetName ASC) FROM Pets;

परिणाम:

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

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

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

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

परिणाम:

+-----------+-----------------------+
| pettypeid |      string_agg       |
+-----------+-----------------------+
|         1 | Tweet                 |
|         2 | Fluffy,Meow,Scratch   |
|         3 | Bark,Fetch,Fluffy,Wag |
+-----------+-----------------------+

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

SELECT 
    pt.PetType,
    STRING_AGG(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 |      string_agg       |
+---------+-----------------------+
| Bird    | Tweet                 |
| Cat     | Fluffy,Meow,Scratch   |
| Dog     | Bark,Fetch,Fluffy,Wag |
+---------+-----------------------+