आप ALL . से परिचित हो सकते हैं SQL सर्वर में विकल्प। शायद आपने इसका उपयोग UNION . के साथ किया हो परिणाम सेट में लौटाए जा सकने वाले किसी भी डुप्लीकेट को शामिल करने के लिए ऑपरेटर।
लेकिन क्या आप जानते हैं कि ALL दो अन्य संदर्भों में भी इस्तेमाल किया जा सकता है?
ALL निम्नलिखित तीन संदर्भों में इस्तेमाल किया जा सकता है:
SELECTके तर्क के रूप में खंड।UNIONके तर्क के रूप में खंड।- एक लॉजिकल ऑपरेटर के रूप में जब एक स्केलर मान की तुलना एकल-स्तंभ मानों के सेट से की जाती है।
इनमें से प्रत्येक संदर्भ के उदाहरण इस प्रकार हैं।
ALL SELECT . में खंड
जब SELECT . के साथ प्रयोग किया जाता है खंड, ALL निर्दिष्ट करता है कि परिणाम सेट में डुप्लिकेट मान लौटाए जाते हैं।
आप शायद पहले से ही बिना जाने ही इसका इस्तेमाल कर रहे हैं।
T-SQL में, SELECT . के लिए सिंटैक्स खंड इस प्रकार है:
SELECT [ ALL | DISTINCT ]
[ TOP ( expression ) [ PERCENT ] [ WITH TIES ] ]
<select_list>
<select_list> ::=
{
*
| { table_name | view_name | table_alias }.*
| {
[ { table_name | view_name | table_alias }. ]
{ column_name | $IDENTITY | $ROWGUID }
| udt_column_name [ { . | :: } { { property_name | field_name }
| method_name ( argument [ ,...n] ) } ]
| expression
[ [ AS ] column_alias ]
}
| column_alias = expression
} [ ,...n ]
वह भाग जो जाता है [ ALL | DISTINCT ] इसका मतलब है कि आपको ALL . के बीच एक विकल्प मिलता है और DISTINCT .
वर्गाकार कोष्ठक का अर्थ है कि यह भाग वैकल्पिक है।
ALLनिर्दिष्ट करता है कि परिणाम सेट में डुप्लिकेट पंक्तियाँ दिखाई दे सकती हैं।DISTINCTनिर्दिष्ट करता है कि परिणाम सेट में केवल अनन्य पंक्तियां दिखाई दे सकती हैं।
ALL डिफ़ॉल्ट मान है, इसलिए यदि आप ALL निर्दिष्ट नहीं करते हैं या DISTINCT , ALL उपयोग किया जाता है।
उदाहरण
तो निम्नलिखित दो कथन समतुल्य हैं:
SELECT DogName
FROM Dogs;
SELECT ALL DogName
FROM Dogs;उदाहरण परिणाम:
+-----------+ | DogName | |-----------| | Fetch | | Fluffy | | Wag | | Fetch | +-----------+ (4 rows affected) +-----------+ | DogName | |-----------| | Fetch | | Fluffy | | Wag | | Fetch | +-----------+ (4 rows affected)
दोनों परिणामों से पता चलता है कि "Fetch" नाम के दो कुत्ते हैं।
अगर हम ALL की अदला-बदली करते हैं DISTINCT . के लिए तर्क , "लाने" के लिए केवल एक पंक्ति लौटा दी जाएगी। ऐसा इसलिए है क्योंकि DISTINCT परिणाम सेट से किसी भी डुप्लिकेट मान को हटा देता है।
SELECT DISTINCT DogName
FROM Dogs;उदाहरण परिणाम:
+-----------+ | DogName | |-----------| | Fetch | | Fluffy | | Wag | +-----------+ (3 rows affected)
ALL UNION . में खंड
ALL वही काम करता है जब UNION . के साथ प्रयोग किया जाता है खंड। यह निर्दिष्ट करता है कि परिणाम सेट में डुप्लिकेट मान लौटाए जाते हैं।
लेकिन जाहिर है, UNION SELECT . के लिए एक अलग क्लॉज है , इसलिए संदर्भ थोड़ा अलग है।
UNION खंड दो प्रश्नों के परिणामों को एक परिणाम सेट में जोड़ता है। आप इसका उपयोग ALL . के साथ या उसके बिना कर सकते हैं तर्क:
UNION ALL- डुप्लीकेट शामिल हैं।UNION- डुप्लीकेट शामिल नहीं हैं।
उदाहरण
यहां UNION ALL का उपयोग करने का एक उदाहरण दिया गया है दो प्रश्नों को संयोजित करने के लिए।
चलिए Cats called नाम की एक टेबल जोड़ते हैं . तो हमारे पास दो टेबल हैं:Dogs और Cats
Dogs
+---------+-----------+ | DogId | DogName | |---------+-----------| | 1 | Fetch | | 2 | Fluffy | | 3 | Wag | | 1002 | Fetch | +---------+-----------+
Cats
+---------+-----------+ | CatId | CatName | |---------+-----------| | 1 | Meow | | 2 | Fluffy | | 3 | Scratch | +---------+-----------+
अब प्रत्येक तालिका से कुत्ते/बिल्ली का नाम चुनें और UNION ALL . का उपयोग करें दोनों तालिकाओं के परिणामों को संयोजित करने के लिए।
SELECT DogName AS PetName
FROM Dogs
UNION ALL
SELECT CatName
FROM Cats;परिणाम:
+-----------+ | PetName | |-----------| | Fetch | | Fluffy | | Wag | | Fetch | | Meow | | Fluffy | | Scratch | +-----------+ (7 rows affected)
इस मामले में, सात पंक्तियों को वापस कर दिया जाता है। हम देख सकते हैं कि "Fetch" दो बार लौटाया जाता है। ऐसा इसलिए है क्योंकि Fetch नाम के दो कुत्ते हैं।
एक ही नाम की एक बिल्ली और एक कुत्ता भी है:शराबी। (हम दूसरे की बिल्ली जानते हैं क्योंकि पिछले उदाहरण में Fluffy नामक केवल एक कुत्ता था)।
देखते हैं कि जब मैं ALL को हटाता हूं तो क्या होता है तर्क।
SELECT DogName AS PetName
FROM Dogs
UNION
SELECT CatName
FROM Cats;परिणाम:
+-----------+ | PetName | |-----------| | Fetch | | Fluffy | | Meow | | Scratch | | Wag | +-----------+ (5 rows affected)
इस बार केवल पाँच पंक्तियाँ लौटाई गई हैं। दोनों डुप्लीकेट हटा दिए गए हैं।
ध्यान दें कि यह लागू करने के लिए अलग है DISTINCT प्रत्येक व्यक्ति को SELECT बयान। अगर हमने ऐसा किया होता, तो Fluffy को दो बार लौटा दिया जाता, क्योंकि ALL केवल SELECT . के लिए लागू होगा यह कथन कि इसके विरुद्ध लागू किया जा रहा है (सम्मिलित परिणामों के लिए नहीं)।
मेरा मतलब समझाने के लिए यहां एक उदाहरण दिया गया है।
SELECT DISTINCT DogName AS PetName
FROM Dogs
UNION ALL
SELECT DISTINCT CatName
FROM Cats;परिणाम:
+-----------+ | PetName | |-----------| | Fetch | | Fluffy | | Wag | | Fluffy | | Meow | | Scratch | +-----------+ (6 rows affected)
ALL संचालिका
ALL सबक्वेरी द्वारा लौटाए गए मानों के एकल-स्तंभ सेट के साथ स्केलर मान की तुलना करने के लिए ऑपरेटर का उपयोग सबक्वेरी के साथ किया जा सकता है।
उदाहरण
एक पुनश्चर्या के रूप में, यहाँ हमारी दो तालिकाएँ हैं:
Dogs
+---------+-----------+ | DogId | DogName | |---------+-----------| | 1 | Fetch | | 2 | Fluffy | | 3 | Wag | | 1002 | Fetch | +---------+-----------+
Cats
+---------+-----------+ | CatId | CatName | |---------+-----------| | 1 | Meow | | 2 | Fluffy | | 3 | Scratch | +---------+-----------+
अब ALL . का उपयोग करके एक सबक्वेरी चलाते हैं ऑपरेटर।
SELECT
CatId,
CatName
FROM Cats c
WHERE c.CatName = ALL (SELECT DogName FROM Dogs);परिणाम:
(0 rows affected)
इस मामले में, कोई पंक्तियाँ वापस नहीं की गईं। ऐसा इसलिए है क्योंकि ALL प्रत्येक . से सकारात्मक रूप से तुलना करने के लिए अदिश व्यंजक की आवश्यकता होती है वह मान जो सबक्वेरी द्वारा लौटाया जाता है।
इस मामले में, सबक्वेरी इतनी व्यापक थी कि Dogs . से सभी पंक्तियाँ तालिका वापस कर दी गई। इसके लिए यह आवश्यक होगा कि प्रत्येक कुत्ते के पास समान नाम वाली कम से कम एक संगत बिल्ली हो।
आइए सबक्वेरी को थोड़ा बदल दें।
SELECT
CatId,
CatName
FROM Cats c
WHERE c.CatName = ALL (
SELECT DogName FROM Dogs
WHERE DogId = 2
);परिणाम:
+---------+-----------+ | CatId | CatName | |---------+-----------| | 2 | Fluffy | +---------+-----------+
इस बार मुझे एक सकारात्मक परिणाम मिला, क्योंकि सबक्वेरी द्वारा लौटाई गई सभी पंक्तियों में Cats में एक समान पंक्ति थी तालिका (इस मामले में, केवल एक पंक्ति)।
