SQLite क्वेरी: चयन करें, कहां, सीमा, ऑफसेट, गणना, समूह द्वारा

नीचे दिए गए अनुभागों में SELECT और FROM का उपयोग करके डेटा पढ़ना, WHERE और इसके ऑपरेटरों का उपयोग करके पंक्तियों को फ़िल्टर करना, परिणामों को क्रमबद्ध और सीमित करना, एग्रीगेट फ़ंक्शन, GROUP BY और HAVING, सबक्वेरी, सेट ऑपरेशन, NULL हैंडलिंग, CASE एक्सप्रेशन और कॉमन टेबल एक्सप्रेशन के बारे में विस्तार से बताया गया है।

लिखना एसक्यूएल प्रश्नों एक में SQLite डेटाबेस में, आपको यह जानना होगा कि SELECT, FROM, WHERE, GROUP BY, ORDER BY, और LIMIT क्लॉज कैसे काम करते हैं और उनका उपयोग कैसे किया जाता है।

इस ट्यूटोरियल के दौरान, आप सीखेंगे कि इन क्लॉज़ का उपयोग कैसे करें और कैसे लिखें SQLite खंड।

चयन के साथ डेटा पढ़ना

SELECT क्लॉज़ वह मुख्य कथन है जिसका उपयोग आप किसी क्वेरी के लिए करते हैं SQLite डेटाबेस। SELECT क्लॉज में, आप बताते हैं कि क्या चुनना है। लेकिन सेलेक्ट क्लॉज से पहले, आइए देखें कि हम FROM क्लॉज का उपयोग करके कहां से डेटा चुन सकते हैं।

FROM क्लॉज का उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि आप डेटा का चयन कहां करना चाहते हैं। फ्रॉम क्लॉज में, आप डेटा का चयन करने के लिए एक या अधिक टेबल या सबक्वेरी निर्दिष्ट कर सकते हैं, जैसा कि हम बाद में ट्यूटोरियल में देखेंगे।

ध्यान दें कि, निम्नलिखित सभी उदाहरणों के लिए, आपको sqlite3.exe चलाना होगा और नमूना डेटाबेस से कनेक्शन खोलना होगा:

चरण 1) इस चरण में,

माय कंप्यूटर खोलें और निम्नलिखित डायरेक्टरी पर जाएं: “C:\sqlite” और फिर “sqlite3.exe” खोलें:

चरण 2) निम्न कमांड का उपयोग करके "TutorialsSampleDB.db" डेटाबेस खोलें:

अब आप डेटाबेस पर किसी भी प्रकार की क्वेरी चलाने के लिए तैयार हैं।

SELECT क्लॉज़ में, आप न केवल कॉलम नाम चुन सकते हैं, बल्कि आपके पास यह निर्दिष्ट करने के लिए कई अन्य विकल्प भी हैं कि क्या चुनना है। जैसा कि निम्नलिखित है:

चुनते हैं *

यह कमांड FROM क्लॉज में सभी संदर्भित तालिकाओं (या सबक्वेरीज़) से सभी कॉलम का चयन करेगा। उदाहरण के लिए:

SELECT *
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

यह दोनों तालिकाओं students और department से सभी कॉलमों का चयन करेगा:

तालिकानाम का चयन करें.*

यह केवल टेबल “tablename” से सभी कॉलम का चयन करेगा। उदाहरण के लिए:

SELECT Students.*
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

यह केवल students तालिका से सभी कॉलम का चयन करेगा:

शाब्दिक मूल्य

शाब्दिक मान एक स्थिर मान है जिसे चयन कथन में निर्दिष्ट किया जा सकता है। आप शाब्दिक मानों का उपयोग सामान्य रूप से उसी तरह कर सकते हैं जिस तरह आप SELECT क्लॉज़ में कॉलम नामों का उपयोग करते हैं। ये शाब्दिक मान SQL क्वेरी द्वारा लौटाई गई पंक्तियों से प्रत्येक पंक्ति के लिए प्रदर्शित किए जाएँगे।

यहां विभिन्न शाब्दिक मानों के कुछ उदाहरण दिए गए हैं जिन्हें आप चुन सकते हैं:

• संख्यात्मक शाब्दिक - किसी भी प्रारूप में संख्याएँ जैसे 1, 2.55, ... आदि।
• स्ट्रिंग लिटरल - कोई भी स्ट्रिंग 'USA', 'यह एक नमूना पाठ है', ... आदि।
• शून्य - शून्य मान.
• Current_TIME – यह आपको वर्तमान समय बताएगा।
• CURRENT_DATE – यह आपको वर्तमान दिनांक देगा.

यह कुछ स्थितियों में उपयोगी हो सकता है जहाँ आपको सभी लौटाई गई पंक्तियों के लिए एक स्थिर मान चुनना होता है। उदाहरण के लिए, यदि आप Students तालिका से सभी छात्रों का चयन करना चाहते हैं, जिसमें एक नया कॉलम है जिसे country कहा जाता है जिसमें “USA” मान होता है, तो आप यह कर सकते हैं:

SELECT *, 'USA' AS Country FROM Students;

इससे आपको सभी छात्रों के कॉलम मिलेंगे, साथ ही एक नया कॉलम “देश” भी मिलेगा:

ध्यान दें कि, यह नया कॉलम देश वास्तव में टेबल में जोड़ा गया नया कॉलम नहीं है। यह एक वर्चुअल कॉलम है, जिसे परिणाम प्रदर्शित करने के लिए क्वेरी में बनाया गया है और इसे टेबल पर नहीं बनाया जाएगा।

नाम और उपनाम

उपनाम कॉलम के लिए एक नया नाम है जो आपको नए नाम के साथ कॉलम चुनने देता है। कॉलम उपनामों को “AS” कीवर्ड का उपयोग करके निर्दिष्ट किया जाता है।

उदाहरण के लिए, यदि आप चाहते हैं कि StudentName कॉलम को “StudentName” के बजाय “StudentName” के रूप में लौटाया जाए, तो आप इसे इस तरह एक उपनाम दे सकते हैं:

SELECT StudentName AS 'Student Name' FROM Students;

इससे आपको छात्रों के नाम “StudentName” के बजाय “StudentName” के रूप में मिलेंगे, जैसे:

ध्यान दें कि कॉलम का नाम अभी भी "StudentName" ही है; StudentName कॉलम का नाम अभी भी वही है, उपनाम से इसमें कोई बदलाव नहीं होता है।

उपनाम स्तंभ नाम को नहीं बदलेगा; यह केवल SELECT खंड में प्रदर्शन नाम को बदल देगा।

इसके अलावा, ध्यान रखें कि, कीवर्ड “AS” वैकल्पिक है, आप इसके बिना भी उपनाम नाम डाल सकते हैं, कुछ इस तरह:

SELECT StudentName 'Student Name' FROM Students;

और यह आपको पिछली क्वेरी के समान ही आउटपुट देगा:

आप सिर्फ़ कॉलम ही नहीं, बल्कि टेबल को भी उपनाम दे सकते हैं। उसी कीवर्ड “AS” के साथ। उदाहरण के लिए, आप यह कर सकते हैं:

SELECT s.* FROM Students AS s;

इससे आपको तालिका में सभी कॉलम मिल जाएंगे छात्र:

यह बहुत उपयोगी हो सकता है यदि आप एक से अधिक टेबल को जोड़ रहे हैं; क्वेरी में पूरा टेबल नाम दोहराने के बजाय, आप प्रत्येक टेबल को एक छोटा उपनाम नाम दे सकते हैं। उदाहरण के लिए, निम्न क्वेरी में:

SELECT Students.StudentName, Departments.DepartmentName
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

यह क्वेरी “छात्र” तालिका से प्रत्येक छात्र का नाम और “विभाग” तालिका से उसके विभाग का नाम चुनेगी:

हालाँकि, उसी क्वेरी को इस तरह लिखा जा सकता है:

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

हमने स्टूडेंट्स टेबल को “s” और डिपार्टमेंट्स टेबल को “d” उपनाम दिया। फिर, टेबल के पूरे नाम का उपयोग करने के बजाय, हमने उन्हें संदर्भित करने के लिए उनके उपनामों का उपयोग किया। INNER JOIN एक शर्त का उपयोग करके दो या दो से अधिक तालिकाओं को आपस में जोड़ता है। हमारे उदाहरण में, हमने स्टूडेंट्स टेबल को डिपार्टमेंट्स टेबल से DepartmentId कॉलम के साथ जोड़ा है। INNER JOIN की विस्तृत व्याख्या “SQLite जुड़ती”ट्यूटोरियल।

इससे आपको पिछली क्वेरी जैसा ही सटीक आउटपुट मिलेगा:

कहां

जैसा कि हमने पिछले अनुभाग में देखा था, FROM क्लॉज के साथ SELECT क्लॉज का उपयोग करके SQL क्वेरी लिखने से आपको टेबल की सभी पंक्तियाँ मिल जाएँगी। हालाँकि, यदि आप लौटाए गए डेटा को फ़िल्टर करना चाहते हैं, तो आपको “WHERE” क्लॉज जोड़ना होगा।

WHERE क्लॉज़ का उपयोग SQL क्वेरी द्वारा लौटाए गए परिणाम सेट को फ़िल्टर करने के लिए किया जाता है। WHERE क्लॉज़ इस प्रकार काम करता है:

• WHERE क्लॉज़ में, आप एक “एक्सप्रेशन” निर्दिष्ट कर सकते हैं।
• उस अभिव्यक्ति का मूल्यांकन FROM खंड में निर्दिष्ट तालिका(ओं) से लौटी प्रत्येक पंक्ति के लिए किया जाएगा।
• अभिव्यक्ति का मूल्यांकन बूलियन अभिव्यक्ति के रूप में किया जाएगा, जिसका परिणाम सत्य, असत्य या शून्य होगा।
• फिर केवल वे पंक्तियाँ लौटाई जाएंगी जिनके लिए अभिव्यक्ति का मूल्यांकन सत्य मान के साथ किया गया था, तथा गलत या शून्य परिणाम वाली पंक्तियों को अनदेखा कर दिया जाएगा तथा परिणाम सेट में शामिल नहीं किया जाएगा।

WHERE क्लॉज़ का उपयोग करके परिणाम सेट को फ़िल्टर करने के लिए, आपको अभिव्यक्तियों और ऑपरेटरों का उपयोग करना होगा।

ऑपरेटरों की सूची SQLite और उनका उपयोग कैसे करें

अगले अनुभाग में, हम बताएंगे कि आप अभिव्यक्ति और ऑपरेटरों का उपयोग करके कैसे फ़िल्टर कर सकते हैं।

अभिव्यक्ति एक या एक से अधिक शाब्दिक मान या कॉलम हैं जो एक ऑपरेटर के साथ एक दूसरे के साथ संयुक्त होते हैं।

ध्यान दें कि, आप SELECT खंड और WHERE खंड दोनों में अभिव्यक्तियों का उपयोग कर सकते हैं।

निम्नलिखित उदाहरणों में, हम select Clause और WHERE Clause दोनों में अभिव्यक्तियों और ऑपरेटरों को आज़माएँगे। ताकि आपको दिखाया जा सके कि वे कैसे काम करते हैं।

विभिन्न प्रकार के अभिव्यक्तियाँ और ऑपरेटर हैं जिन्हें आप निम्नानुसार निर्दिष्ट कर सकते हैं:

SQLite संयोजन ऑपरेटर “||”

इस ऑपरेटर का उपयोग एक या अधिक शाब्दिक मानों या स्तंभों को एक दूसरे के साथ संयोजित करने के लिए किया जाता है। यह सभी संयोजित शाब्दिक मानों या स्तंभों से परिणामों की एक स्ट्रिंग तैयार करेगा। उदाहरण के लिए:

SELECT 'Id with Name: '|| StudentId || StudentName AS StudentIdWithName
FROM Students;

इससे एक नया उपनाम "StudentIdWithName" बनेगा:

• शाब्दिक स्ट्रिंग मान “नाम के साथ आईडी: “
• “StudentId” कॉलम के मान के साथ और
• “StudentName” कॉलम के मान के साथ

SQLite CAST ऑपरेटर:

CAST ऑपरेटर का उपयोग किसी मान को परिवर्तित करने के लिए किया जाता है। डाटा प्रकार किसी अन्य डेटा प्रकार में।

उदाहरण के लिए, यदि आपके पास "12.5" जैसी स्ट्रिंग वैल्यू के रूप में संग्रहीत कोई संख्यात्मक मान है और आप इसे वास्तविक संख्यात्मक मान में बदलना चाहते हैं, तो आप CAST ऑपरेटर का उपयोग करके ऐसा कर सकते हैं: "CAST('12.5' ​​AS REAL)"। या यदि आपके पास 12.5 जैसा दशमलव मान है और आपको केवल पूर्णांक भाग प्राप्त करना है, तो आप इसे पूर्णांक में इस प्रकार बदल सकते हैं: "CAST(12.5 AS INTEGER)"।

उदाहरण

निम्नलिखित कमांड में हम विभिन्न मानों को अन्य डेटा प्रकारों में परिवर्तित करने का प्रयास करेंगे:

SELECT CAST('12.5' AS REAL) ToReal, CAST(12.5 AS INTEGER) AS ToInteger;

इससे आपको मिलेगा:

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

• CAST('12.5' ​​AS REAL) - मान '12.5' ​​एक स्ट्रिंग मान है, इसे REAL मान में परिवर्तित किया जाएगा।
• CAST(12.5 AS INTEGER) – मान 12.5 एक दशमलव मान है, इसे पूर्णांक मान में परिवर्तित किया जाएगा। दशमलव भाग को छोटा कर दिया जाएगा, और यह 12 हो जाएगा।

SQLite अंकगणित Operaटोर्स:

दो या अधिक संख्यात्मक शाब्दिक मान या संख्यात्मक कॉलम लें और एक संख्यात्मक मान लौटाएँ। इसमें समर्थित अंकगणितीय ऑपरेटर SQLite यह है:

• जोड़ “+” – दो ऑपरेंड का योग देता है।
• उपtraction “–” – उपtracयह दो ऑपरेंड को जोड़ता है और अंतर उत्पन्न करता है।
• गुणन “*” – दो ऑपरेंड का गुणनफल।
• शेषफल (मॉड्यूलो) “%” – एक ऑपरेंड को दूसरे ऑपरेंड से विभाजित करने पर प्राप्त शेषफल बताता है।
• भागफल “/” – बाएँ ऑपरेंड को दाएँ ऑपरेंड से भाग देने पर प्राप्त भागफल लौटाता है।

उदाहरण:

निम्नलिखित उदाहरण में, हम एक ही सेलेक्ट क्लॉज़ में शाब्दिक संख्यात्मक मानों के साथ पांच अंकगणितीय ऑपरेटरों को आज़माएंगे:

SELECT 25+6, 25-6, 25*6, 25%6, 25/6;

इससे आपको मिलेगा:

ध्यान दें कि हमने यहाँ FROM क्लॉज़ के बिना SELECT कथन का उपयोग कैसे किया। और इसकी अनुमति है SQLite जब तक हम शाब्दिक मूल्यों का चयन करते हैं।

SQLite तुलना ऑपरेटरों

दो ऑपरेंडों की एक दूसरे से तुलना करें और निम्नानुसार सत्य या असत्य लौटाएं:

• “<” – यदि बायां ऑपरेंड दाएं ऑपरेंड से छोटा है तो true लौटाता है।
• “<=” – यदि बायां ऑपरेंड दाएं ऑपरेंड से छोटा या बराबर है तो true लौटाता है।
• “>” – यदि बायां ऑपरेंड दाएं ऑपरेंड से बड़ा है तो true लौटाता है।
• “>=” – यदि बायां ऑपरेंड दाएं ऑपरेंड से बड़ा या बराबर है तो true लौटाता है।
• “=” और “==” – दोनों ऑपरेंड बराबर होने पर true लौटाते हैं। ध्यान दें कि दोनों ऑपरेटर एक ही हैं, उनमें कोई अंतर नहीं है।
• “!=” और “<>” – दोनों ऑपरेंड बराबर न होने पर true लौटाते हैं। ध्यान दें कि दोनों ऑपरेटर एक ही हैं, उनमें कोई अंतर नहीं है।

ध्यान दें कि, SQLite सत्य मान को 1 तथा असत्य मान को 0 से व्यक्त करता है।

उदाहरण:

SELECT
  10<6 AS '<', 10<=6 AS '<=',
  10>6 AS '>', 10>=6 AS '>=',
  10=6 AS '=', 10==6 AS '==',
  10!=6 AS '!=', 10<>6 AS '<>';

इससे कुछ इस तरह का परिणाम मिलेगा:

SQLite पैटर्न मिलान ऑपरेटर

“LIKE” का उपयोग पैटर्न मिलान के लिए किया जाता है। “Like” का उपयोग करके, आप वाइल्डकार्ड द्वारा निर्दिष्ट पैटर्न से मेल खाने वाले मानों को खोज सकते हैं।

बाईं ओर का ऑपरेंड या तो स्ट्रिंग लिटरल मान या स्ट्रिंग कॉलम हो सकता है। पैटर्न को निम्न प्रकार से निर्दिष्ट किया जा सकता है:

• इसमें एक पैटर्न शामिल है। उदाहरण के लिए, StudentName LIKE '%a%' – यह उन छात्रों के नामों को खोजेगा जिनमें StudentName कॉलम में किसी भी स्थान पर अक्षर "a" मौजूद हो।
• यह एक पैटर्न से शुरू होता है। उदाहरण के लिए, "StudentName LIKE 'a%'" - उन छात्रों के नामों को खोजें जो अक्षर "a" से शुरू होते हैं।
• यह एक पैटर्न के साथ समाप्त होता है। उदाहरण के लिए, "StudentName LIKE '%a'" - उन छात्रों के नामों को खोजें जिनके नाम "a" अक्षर से समाप्त होते हैं।
• स्ट्रिंग में किसी भी एक अक्षर का मिलान करने के लिए अंडरस्कोर अक्षर “_” का उपयोग करें। उदाहरण के लिए, “StudentName LIKE 'J___'” – चार अक्षरों वाले छात्रों के नाम खोजें। नाम की शुरुआत “J” अक्षर से होनी चाहिए और इसके बाद कोई भी तीन अक्षर हो सकते हैं।

पैटर्न मिलान के उदाहरण:

'j' अक्षर से शुरू होने वाले छात्रों के नाम प्राप्त करें:

SELECT StudentName FROM Students WHERE StudentName LIKE 'j%';

रिजल्ट:

'y' अक्षर से समाप्त होने वाले छात्रों के नाम प्राप्त करें:

SELECT StudentName FROM Students WHERE StudentName LIKE '%y';

रिजल्ट:

'n' अक्षर वाले छात्रों के नाम प्राप्त करें:

SELECT StudentName FROM Students WHERE StudentName LIKE '%n%';

रिजल्ट:

“GLOB” – LIKE ऑपरेटर के समतुल्य है, लेकिन LIKE ऑपरेटर के विपरीत GLOB केस सेंसिटिव है। उदाहरण के लिए, निम्नलिखित दो कमांड अलग-अलग परिणाम देंगे:

SELECT 'Jack' GLOB 'j%';
SELECT 'Jack' LIKE 'j%';

इससे आपको मिलेगा:

पहला कथन 0 (गलत) लौटाता है क्योंकि GLOB ऑपरेटर केस सेंसिटिव है, इसलिए 'j' 'J' के बराबर नहीं है। हालाँकि, दूसरा कथन 1 (सत्य) लौटाएगा क्योंकि LIKE ऑपरेटर केस सेंसिटिव नहीं है, इसलिए 'j' 'J' के बराबर है।

अन्य ऑपरेटर:

SQLite और

एक तार्किक ऑपरेटर जो एक या अधिक अभिव्यक्तियों को जोड़ता है। यह तभी सत्य लौटाएगा, जब सभी अभिव्यक्तियाँ “सत्य” मान देंगी। हालाँकि, यह तभी असत्य लौटाएगा, जब सभी अभिव्यक्तियाँ “असत्य” मान देंगी।

उदाहरण:

निम्नलिखित क्वेरी उन छात्रों की खोज करेगी जिनकी StudentId > 5 है और StudentName अक्षर N से शुरू होता है, लौटाए गए छात्रों को दो शर्तों को पूरा करना होगा:

SELECT *
FROM Students
WHERE (StudentId > 5) AND (StudentName LIKE 'N%');

आउटपुट के तौर पर, ऊपर दिए गए स्क्रीनशॉट में, यह आपको सिर्फ़ “नैन्सी” देगा। नैन्सी एकमात्र छात्रा है जो दोनों शर्तों को पूरा करती है।

SQLite OR

एक तार्किक ऑपरेटर जो एक या अधिक अभिव्यक्तियों को जोड़ता है, ताकि यदि संयुक्त ऑपरेटरों में से एक सत्य देता है, तो यह सत्य लौटाएगा। हालाँकि, यदि सभी अभिव्यक्तियाँ असत्य देती हैं, तो यह असत्य लौटाएगा।

उदाहरण:

निम्नलिखित क्वेरी उन छात्रों की खोज करेगी जिनकी StudentId > 5 है या StudentName अक्षर N से शुरू होता है, लौटाए गए छात्रों को कम से कम एक शर्त पूरी करनी होगी:

SELECT *
FROM Students
WHERE (StudentId > 5) OR (StudentName LIKE 'N%');

इससे आपको मिलेगा:

आउटपुट के रूप में, उपरोक्त स्क्रीनशॉट में, यह आपको एक छात्र का नाम देगा जिसके नाम में अक्षर “n” होगा और छात्र आईडी का मान 5 से अधिक होगा।

जैसा कि आप देख सकते हैं, परिणाम AND ऑपरेटर वाली क्वेरी से भिन्न है।

SQLite बीच

BETWEEN फ़ंक्शन का उपयोग दो मानों की सीमा के भीतर आने वाले मानों को चुनने के लिए किया जाता है। उदाहरण के लिए, “X BETWEEN Y AND Z” सही (1) मान लौटाएगा यदि मान X, Y और Z के बीच में है। अन्यथा, यह गलत (0) मान लौटाएगा। “X BETWEEN Y AND Z” “X >= Y AND X <= Z” के समतुल्य है, जहाँ X, Y से बड़ा या बराबर होना चाहिए और X, Z से छोटा या बराबर होना चाहिए।

उदाहरण:

निम्नलिखित उदाहरण क्वेरी में, हम 5 से 8 के बीच Id मान वाले छात्रों को प्राप्त करने के लिए एक क्वेरी लिखेंगे:

SELECT *
FROM Students
WHERE StudentId BETWEEN 5 AND 8;

इससे केवल आईडी 5, 6, 7 और 8 वाले विद्यार्थियों को ही जानकारी मिलेगी:

SQLite IN

एक ऑपरेंड और ऑपरेंड की एक सूची लेता है। यदि पहला ऑपरेंड मान सूची में से किसी एक ऑपरेंड के मान के बराबर है, तो यह सत्य लौटाएगा। यदि ऑपरेंड की सूची में उसके मानों के भीतर पहला ऑपरेंड मान शामिल है, तो IN ऑपरेटर सत्य (1) लौटाता है। अन्यथा, यह गलत (0) लौटाएगा।

इस प्रकार: “col IN(x, y, z)“। यह ” (col=x) या (col=y) या (col=z) ” के समतुल्य है।

उदाहरण:

निम्नलिखित क्वेरी केवल आईडी 2, 4, 6, 8 वाले छात्रों का चयन करेगी:

SELECT *
FROM Students
WHERE StudentId IN(2, 4, 6, 8);

इस कदर:

पिछली क्वेरी निम्नलिखित क्वेरी के समान ही परिणाम देगी क्योंकि वे समतुल्य हैं:

SELECT *
FROM Students
WHERE (StudentId = 2) OR (StudentId =  4) OR (StudentId =  6) OR (StudentId = 8);

दोनों क्वेरीज़ सटीक आउटपुट देती हैं। हालाँकि, दोनों क्वेरीज़ के बीच अंतर यह है कि पहली क्वेरी में हमने “IN” ऑपरेटर का इस्तेमाल किया था। दूसरी क्वेरी में, हमने कई “OR” ऑपरेटर का इस्तेमाल किया।

IN ऑपरेटर एकाधिक OR ऑपरेटरों के उपयोग के समतुल्य है। “WHERE StudentId IN(2, 4, 6, 8)” का अर्थ है “WHERE (StudentId = 2) OR (StudentId = 4) OR (StudentId = 6) OR (StudentId = 8);“

इस कदर:

SQLite अंदर नही

“NOT IN” ऑपरेंड, IN ऑपरेटर का विपरीत होता है। लेकिन इसका सिंटैक्स समान होता है; यह एक ऑपरेंड और ऑपरेंड की एक सूची लेता है। यदि पहले ऑपरेंड का मान सूची में मौजूद किसी भी ऑपरेंड के मान के बराबर नहीं है, तो यह true (0) लौटाएगा। उदाहरण के लिए: “col NOT IN(x, y, z)”। यह “(col<>x) AND (col<>y) AND (col<>z)” के समतुल्य है।

उदाहरण:

निम्नलिखित क्वेरी उन विद्यार्थियों का चयन करेगी जिनकी आईडी इन आईडी 2, 4, 6, 8 में से किसी एक के बराबर नहीं है:

SELECT *
FROM Students
WHERE StudentId NOT IN(2, 4, 6, 8);

इस तरह

पिछली क्वेरी का परिणाम हम निम्नलिखित क्वेरी के समान ही देते हैं क्योंकि वे समतुल्य हैं:

SELECT *
FROM Students
WHERE (StudentId <> 2) AND (StudentId <> 4) AND (StudentId <> 6) AND (StudentId <> 8);

इस कदर:

उपरोक्त स्क्रीनशॉट में,

हमने छात्रों की एक सूची प्राप्त करने के लिए कई बराबर नहीं ऑपरेटरों “<>” का उपयोग किया, जो निम्नलिखित आईडी 2, 4, 6, और 8 में से किसी के बराबर नहीं हैं। यह क्वेरी आईडी की इन सूचियों के अलावा अन्य सभी छात्रों को वापस कर देगी।

SQLite मौजूद है

EXISTS ऑपरेटर कोई ऑपरेंड नहीं लेता; यह उसके बाद केवल SELECT क्लॉज़ लेता है। यदि SELECT क्लॉज़ से कोई भी पंक्ति वापस आती है, तो EXISTS ऑपरेटर true (1) लौटाएगा, और यदि SELECT क्लॉज़ से कोई भी पंक्ति वापस नहीं आती है, तो यह false (0) लौटाएगा।

उदाहरण:

निम्नलिखित उदाहरण में, यदि विभाग आईडी students तालिका में मौजूद है, तो हम विभाग का नाम चुनेंगे:

SELECT DepartmentName
FROM Departments AS d
WHERE EXISTS (SELECT DepartmentId FROM Students AS s WHERE d.DepartmentId = s.DepartmentId);

इससे आपको मिलेगा:

केवल तीन विभाग “आईटी, भौतिकी और कला” ही दिखाए जाएंगे। “गणित” विभाग नहीं दिखाया जाएगा क्योंकि उस विभाग में कोई छात्र नहीं है, इसलिए छात्रों की तालिका में विभाग आईडी मौजूद नहीं है। यही कारण है कि EXISTS ऑपरेटर ने “गणित” विभाग को अनदेखा कर दिया।

SQLite नहीं

Reverseयह इसके बाद आने वाले पूर्ववर्ती ऑपरेटर का परिणाम है। उदाहरण के लिए:

• NOT BETWEEN - यदि BETWEEN गलत लौटाता है तो यह सत्य लौटाएगा और इसके विपरीत।
• NOT LIKE - यदि LIKE गलत लौटाता है तो यह सत्य लौटाएगा और इसके विपरीत।
• NOT GLOB - यदि GLOB गलत लौटाता है तो यह सत्य लौटाएगा और इसके विपरीत।
• NOT EXISTS - यदि EXISTS गलत लौटाता है तो यह सत्य लौटाएगा और इसके विपरीत।

उदाहरण:

निम्नलिखित उदाहरण में, हम EXISTS ऑपरेटर के साथ NOT ऑपरेटर का उपयोग उन विभागों के नाम प्राप्त करने के लिए करेंगे जो Students तालिका में मौजूद नहीं हैं, जो EXISTS ऑपरेटर का उल्टा परिणाम है। इसलिए, खोज DepartmentId के माध्यम से की जाएगी जो विभाग तालिका में मौजूद नहीं है।

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId
                  FROM Students AS s
                  WHERE d.DepartmentId = s.DepartmentId);

आउटपुट:

केवल "गणित" विभाग ही दिखाया जाएगा। चूंकि "गणित" विभाग एकमात्र विभाग है, इसलिए यह छात्रों की तालिका में मौजूद नहीं है।

सीमित करना और आदेश देना

SQLite व्यवस्था

SQLite ऑर्डर आपके परिणाम को एक या अधिक अभिव्यक्तियों के आधार पर क्रमबद्ध करना है। परिणाम सेट को क्रमबद्ध करने के लिए, आपको निम्न प्रकार से ORDER BY क्लॉज़ का उपयोग करना होगा:

• सबसे पहले, आपको ORDER BY क्लॉज़ निर्दिष्ट करना होगा।
• ORDER BY क्लॉज को क्वेरी के अंत में निर्दिष्ट किया जाना चाहिए; इसके बाद केवल LIMIT क्लॉज निर्दिष्ट किया जा सकता है।
• डेटा को क्रमित करने के लिए अभिव्यक्ति निर्दिष्ट करें, यह अभिव्यक्ति एक स्तंभ नाम या एक अभिव्यक्ति हो सकती है।
• अभिव्यक्ति के बाद, आप वैकल्पिक सॉर्ट दिशा निर्दिष्ट कर सकते हैं। डेटा को अवरोही क्रम में क्रमबद्ध करने के लिए DESC या डेटा को आरोही क्रम में क्रमबद्ध करने के लिए ASC। यदि आपने उनमें से कोई भी निर्दिष्ट नहीं किया है, तो डेटा आरोही क्रम में क्रमबद्ध किया जाएगा।
• आप एक दूसरे के बीच “,” का उपयोग करके अधिक अभिव्यक्तियाँ निर्दिष्ट कर सकते हैं।

उदाहरण

निम्नलिखित उदाहरण में, हम सभी विद्यार्थियों का चयन उनके नाम के अनुसार अवरोही क्रम में, फिर विभाग के नाम के अनुसार आरोही क्रम में करेंगे:

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
ORDER BY d.DepartmentName ASC , s.StudentName DESC;

इससे आपको मिलेगा:

• SQLite सबसे पहले सभी छात्रों को उनके विभाग के नाम के अनुसार आरोही क्रम में व्यवस्थित किया जाएगा
• फिर प्रत्येक विभाग के नाम के लिए, उस विभाग के नाम के अंतर्गत सभी छात्रों को उनके नाम के अनुसार अवरोही क्रम में प्रदर्शित किया जाएगा

SQLite सीमा:

आप LIMIT क्लॉज़ का उपयोग करके अपनी SQL क्वेरी द्वारा लौटाई गई पंक्तियों की संख्या को सीमित कर सकते हैं। उदाहरण के लिए, LIMIT 10 आपको केवल 10 पंक्तियाँ देगा और अन्य सभी पंक्तियों को अनदेखा कर देगा।

LIMIT क्लॉज़ में, आप OFFSET क्लॉज़ का उपयोग करके किसी विशिष्ट स्थिति से शुरू होने वाली पंक्तियों की एक निश्चित संख्या का चयन कर सकते हैं। उदाहरण के लिए, "LIMIT 4 OFFSET 4" पहली 4 पंक्तियों को अनदेखा कर देगा और पाँचवीं पंक्ति से शुरू होने वाली 4 पंक्तियाँ लौटाएगा, इस प्रकार आपको पंक्तियाँ 5, 6, 7 और 8 प्राप्त होंगी।

ध्यान दें कि OFFSET क्लॉज़ वैकल्पिक है, आप इसे "LIMIT 4, 4" की तरह लिख सकते हैं और इससे आपको सटीक परिणाम मिलेंगे।

उदाहरण:

निम्नलिखित उदाहरण में, हम क्वेरी का उपयोग करके छात्र आईडी 3 से शुरू करते हुए केवल 5 छात्रों को लौटाएंगे:

SELECT * FROM Students LIMIT 4,3;

इससे आपको पंक्ति 5 से शुरू करते हुए केवल तीन छात्र मिलेंगे। इसलिए यह आपको StudentId 5, 6, और 7 वाली पंक्तियाँ देगा:

डुप्लीकेट हटाना

यदि आपकी SQL क्वेरी में डुप्लिकेट मान मिलते हैं, तो आप उन डुप्लिकेट मानों को हटाने और केवल विशिष्ट मान प्राप्त करने के लिए "DISTINCT" कीवर्ड का उपयोग कर सकते हैं। DISTINCT कुंजी के बाद आप एक से अधिक कॉलम निर्दिष्ट कर सकते हैं।

उदाहरण:

निम्नलिखित क्वेरी डुप्लिकेट "विभाग नाम मान" लौटाएगी: यहां हमारे पास आईटी, भौतिकी और कला नामों के साथ डुप्लिकेट मान हैं।

SELECT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

इससे आपको विभाग के नाम के लिए डुप्लिकेट मान मिलेंगे:

ध्यान दें, विभाग के नाम के लिए डुप्लिकेट मान कैसे हैं। अब, हम उन डुप्लिकेट को हटाने और केवल अद्वितीय मान प्राप्त करने के लिए उसी क्वेरी के साथ DISTINCT कीवर्ड का उपयोग करेंगे। इस तरह:

SELECT DISTINCT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

इससे आपको विभाग नाम कॉलम के लिए केवल तीन अद्वितीय मान मिलेंगे:

कुल

SQLite समुच्चय अंतर्निहित फ़ंक्शन हैं जिन्हें परिभाषित किया गया है SQLite जो एकाधिक पंक्तियों के एकाधिक मानों को एक मान में समूहित करेगा।

यहां पर निम्नलिखित द्वारा समर्थित समुच्चय दिए गए हैं: SQLite:

SQLite AVG()

सभी x मानों का औसत लौटाया गया.

उदाहरण:

निम्नलिखित उदाहरण में हम सभी परीक्षाओं में छात्रों द्वारा प्राप्त औसत अंक प्राप्त करेंगे:

SELECT AVG(Mark) FROM Marks;

इससे आपको “18.375” का मान मिलेगा:

ये परिणाम सभी अंक मानों के योग को उनकी गिनती से विभाजित करने पर प्राप्त होते हैं।

COUNT() – COUNT(X) या COUNT(*)

x मान के प्रकट होने की कुल संख्या लौटाता है। और यहाँ कुछ विकल्प दिए गए हैं जिनका उपयोग आप COUNT के साथ कर सकते हैं:

• COUNT(x): केवल x मानों की गणना करता है, जहाँ x एक कॉलम नाम है। यह NULL मानों को अनदेखा कर देगा।
• COUNT(*): सभी स्तंभों से सभी पंक्तियों की गणना करें।
• COUNT (DISTINCT x): आप x से पहले DISTINCT कीवर्ड निर्दिष्ट कर सकते हैं जो x के विशिष्ट मानों की गणना प्राप्त करेगा।

उदाहरण

निम्नलिखित उदाहरण में, हम COUNT(DepartmentId), COUNT(*) और COUNT(DISTINCT DepartmentId) वाले विभागों की कुल संख्या प्राप्त करेंगे और देखेंगे कि वे किस प्रकार भिन्न हैं:

SELECT COUNT(DepartmentId), COUNT(DISTINCT DepartmentId), COUNT(*) FROM Students;

इससे आपको मिलेगा:

के रूप में निम्नानुसार:

• COUNT(DepartmentId) आपको सभी विभाग आईडी की गिनती देगा, और यह शून्य मानों को अनदेखा कर देगा।
• COUNT(DISTINCT DepartmentId) आपको DepartmentId के अलग-अलग मान देता है, जो केवल 3 हैं। जो विभाग के नाम के तीन अलग-अलग मान हैं। ध्यान दें कि छात्र के नाम में विभाग के नाम के 8 मान हैं। लेकिन केवल तीन अलग-अलग मान जो गणित, आईटी और भौतिकी हैं।
• COUNT(*) छात्रों की तालिका में पंक्तियों की संख्या गिनता है जो 10 छात्रों के लिए 10 पंक्तियाँ हैं।

GROUP_CONCAT() – GROUP_CONCAT(X) या GROUP_CONCAT(X,Y)

GROUP_CONCAT एग्रीगेट फ़ंक्शन एकाधिक मानों को अल्पविराम से अलग करके एक मान में संयोजित करता है। इसमें निम्नलिखित विकल्प हैं:

• GROUP_CONCAT(X): यह x के सभी मानों को एक स्ट्रिंग में संयोजित करेगा, जिसमें अल्पविराम “,” का उपयोग मानों के बीच विभाजक के रूप में किया जाएगा। शून्य मानों को अनदेखा किया जाएगा।
• GROUP_CONCAT(X, Y): यह x के मानों को एक स्ट्रिंग में संयोजित करेगा, जिसमें y का मान डिफ़ॉल्ट विभाजक ',' के बजाय प्रत्येक मान के बीच विभाजक के रूप में उपयोग किया जाएगा। NULL मानों को भी अनदेखा किया जाएगा।
• GROUP_CONCAT(DISTINCT X): यह x के सभी अलग-अलग मानों को एक स्ट्रिंग में संयोजित करेगा, जिसमें अल्पविराम “,” का उपयोग मानों के बीच विभाजक के रूप में किया जाएगा। NULL मानों को अनदेखा किया जाएगा।

GROUP_CONCAT(DepartmentName) उदाहरण

निम्नलिखित क्वेरी छात्रों और विभागों की तालिका से सभी विभाग नाम के मानों को अल्पविराम से अलग करके एक स्ट्रिंग में संयोजित करेगी। इसलिए मानों की सूची लौटाने के बजाय, प्रत्येक पंक्ति पर एक मान लौटाएगा। यह एक पंक्ति पर केवल एक मान लौटाएगा, जिसमें सभी मान अल्पविराम से अलग होंगे:

SELECT GROUP_CONCAT(d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

इससे आपको मिलेगा:

इससे आपको 8 विभागों के नाम मानों की सूची मिलेगी जो अल्पविराम से अलग करके एक स्ट्रिंग में संयोजित होंगे।

GROUP_CONCAT(DISTINCT विभागनाम) उदाहरण

निम्नलिखित क्वेरी छात्रों और विभागों तालिका से विभाग के नाम के अलग-अलग मानों को अल्पविराम से अलग करके एक स्ट्रिंग में संयोजित करेगी:

SELECT GROUP_CONCAT(DISTINCT d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

इससे आपको मिलेगा:

ध्यान दें कि परिणाम पिछले परिणाम से किस प्रकार भिन्न है; केवल तीन मान लौटाए गए जो कि अलग-अलग विभागों के नाम हैं, तथा डुप्लिकेट मान हटा दिए गए हैं।

GROUP_CONCAT(DepartmentName ,'&') उदाहरण

निम्नलिखित क्वेरी छात्रों और विभागों तालिका से विभाग नाम कॉलम के सभी मानों को एक स्ट्रिंग में संयोजित करेगी, लेकिन विभाजक के रूप में अल्पविराम के बजाय '&' वर्ण का उपयोग करेगी:

SELECT GROUP_CONCAT(d.DepartmentName, '&')
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

इससे आपको मिलेगा:

ध्यान दें कि मानों के बीच अंतर करने के लिए डिफ़ॉल्ट वर्ण “,” के स्थान पर वर्ण “&” का उपयोग किया गया है।

SQLite अधिकतम() और न्यूनतम()

MAX(X) आपको X मानों में से सबसे बड़ा मान लौटाता है। अगर x के सभी मान शून्य हैं, तो MAX एक NULL मान लौटाएगा। जबकि MIN(X) आपको X मानों में से सबसे छोटा मान लौटाता है। अगर X के सभी मान शून्य हैं, तो MIN एक NULL मान लौटाएगा।

उदाहरण

निम्नलिखित क्वेरी में, हम "मार्क्स" टेबल से उच्चतम और निम्नतम अंक प्राप्त करने के लिए MIN और MAX फ़ंक्शन का उपयोग करेंगे:

SELECT MAX(Mark), MIN(Mark) FROM Marks;

इससे आपको मिलेगा:

SQLite योग(x), कुल(x)

दोनों ही सभी x मानों का योग लौटाएंगे। लेकिन वे निम्नलिखित में भिन्न हैं:

• यदि सभी मान शून्य हैं तो SUM शून्य लौटाएगा, लेकिन कुल 0 लौटाएगा।
• TOTAL हमेशा फ़्लोटिंग पॉइंट मान लौटाता है। यदि सभी x मान पूर्णांक हैं, तो SUM एक पूर्णांक मान लौटाता है। हालाँकि, यदि मान पूर्णांक नहीं हैं, तो यह फ़्लोटिंग पॉइंट मान लौटाएगा।

उदाहरण

निम्नलिखित क्वेरी में हम "मार्क्स" टेबल में मौजूद सभी मार्क्स का योग प्राप्त करने के लिए SUM और total का उपयोग करेंगे:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks;

इससे आपको मिलेगा:

जैसा कि आप देख सकते हैं, TOTAL हमेशा एक फ़्लोटिंग पॉइंट लौटाता है। लेकिन SUM एक पूर्णांक मान लौटाता है क्योंकि “मार्क” कॉलम में मान पूर्णांक में हो सकते हैं।

SUM और TOTAL के बीच अंतर का उदाहरण:

निम्नलिखित क्वेरी में हम SUM और TOTAL के बीच अंतर दिखाएंगे जब उन्हें NULL मानों का SUM मिलेगा:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks WHERE TestId = 4;

इससे आपको मिलेगा:

ध्यान दें कि TestId = 4 के लिए कोई चिह्न नहीं है, इसलिए उस परीक्षण के लिए शून्य मान हैं। SUM रिक्त के रूप में शून्य मान लौटाता है, जबकि TOTAL 0 लौटाता है।

द्वारा समूह बनाएं

GROUP BY क्लॉज़ का उपयोग एक या अधिक कॉलम निर्दिष्ट करने के लिए किया जाता है जिसका उपयोग पंक्तियों को समूहों में समूहित करने के लिए किया जाएगा। समान मान वाली पंक्तियों को समूहों में एक साथ इकट्ठा (व्यवस्थित) किया जाएगा।

किसी अन्य कॉलम के लिए जो कॉलम द्वारा समूह में शामिल नहीं है, आप उसके लिए एक समग्र फ़ंक्शन का उपयोग कर सकते हैं।

उदाहरण:

निम्नलिखित प्रश्न आपको प्रत्येक विभाग में उपस्थित छात्रों की कुल संख्या बताएगा।

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName;

इससे आपको मिलेगा:

GROUPBY DepartmentName क्लॉज सभी छात्रों को प्रत्येक विभाग के नाम के लिए एक समूह में समूहित करेगा। “विभाग” के प्रत्येक समूह के लिए, यह उस पर छात्रों की गिनती करेगा।

HAVING खंड

यदि आप GROUP BY क्लॉज द्वारा लौटाए गए समूहों को फ़िल्टर करना चाहते हैं, तो आप GROUP BY के बाद अभिव्यक्ति के साथ “HAVING” क्लॉज निर्दिष्ट कर सकते हैं। अभिव्यक्ति का उपयोग इन समूहों को फ़िल्टर करने के लिए किया जाएगा।

उदाहरण

निम्नलिखित क्वेरी में, हम उन विभागों का चयन करेंगे जिनमें केवल दो छात्र हैं:

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName
HAVING COUNT(s.StudentId) = 2;

इससे आपको मिलेगा:

क्लॉज HAVING COUNT(S.StudentId) = 2 लौटाए गए समूहों को फ़िल्टर करेगा और केवल उन समूहों को लौटाएगा जिनमें ठीक दो छात्र हैं। हमारे मामले में, कला विभाग में 2 छात्र हैं, इसलिए इसे आउटपुट में प्रदर्शित किया जाता है।

SQLite क्वेरी और सबक्वेरी

किसी भी क्वेरी के अंदर, आप SELECT, INSERT, DELETE, UPDATE या किसी अन्य सबक्वेरी के अंदर किसी अन्य क्वेरी का उपयोग कर सकते हैं।

इस नेस्टेड क्वेरी को सबक्वेरी कहा जाता है। अब हम SELECT क्लॉज में सबक्वेरी का उपयोग करने के कुछ उदाहरण देखेंगे। हालाँकि, डेटा संशोधित करने वाले ट्यूटोरियल में, हम देखेंगे कि हम INSERT, DELETE और UPDATE स्टेटमेंट के साथ सबक्वेरी का उपयोग कैसे कर सकते हैं।

FROM क्लॉज़ उदाहरण में सबक्वेरी का उपयोग करना

निम्नलिखित क्वेरी में हम FROM क्लॉज़ के अंदर एक सबक्वेरी शामिल करेंगे:

SELECT
  s.StudentName, t.Mark
FROM Students AS s
INNER JOIN
(
   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId
)  ON s.StudentId = t.StudentId;

पूछताछ:

   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId

उपरोक्त क्वेरी को यहाँ सबक्वेरी कहा जाता है क्योंकि यह FROM क्लॉज़ के अंदर नेस्टेड है। ध्यान दें कि हमने इसे एक उपनाम नाम “t” दिया है ताकि हम क्वेरी में इससे लौटाए गए कॉलम को संदर्भित कर सकें।

यह क्वेरी आपको देगी:

तो हमारे मामले में,

• s.StudentName मुख्य क्वेरी से चुना जाता है जो छात्रों का नाम देता है और
• t.Mark को सबक्वेरी से चुना जाता है; जो प्रत्येक छात्र द्वारा प्राप्त अंक देता है

WHERE क्लॉज़ उदाहरण में सबक्वेरी का उपयोग करना

निम्नलिखित क्वेरी में हम WHERE क्लॉज़ में एक सबक्वेरी शामिल करेंगे:

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId
                  FROM Students AS s
                  WHERE d.DepartmentId = s.DepartmentId);

पूछताछ:

SELECT DepartmentId
FROM Students AS s
WHERE d.DepartmentId = s.DepartmentId

उपरोक्त क्वेरी को यहाँ सबक्वेरी कहा जाता है क्योंकि यह WHERE क्लॉज़ में नेस्टेड है। सबक्वेरी डिपार्टमेंटआईडी मान लौटाएगी जिसका उपयोग ऑपरेटर NOT EXISTS द्वारा किया जाएगा।

यह क्वेरी आपको देगी:

उपरोक्त क्वेरी में, हमने उस विभाग का चयन किया है जिसमें कोई छात्र नामांकित नहीं है। जो यहाँ पर “गणित” विभाग है।

सेट Operaयूनियन, इंटरसेक्ट

SQLite निम्नलिखित SET ऑपरेशन का समर्थन करता है:

यूनियन और यूनियन ऑल

यह एकाधिक SELECT कथनों से लौटाए गए एक या अधिक परिणाम सेट (पंक्तियों का एक समूह) को एक परिणाम सेट में संयोजित करता है।

UNION अलग-अलग मान लौटाएगा। हालाँकि, UNION ALL ऐसा नहीं करेगा और इसमें डुप्लिकेट शामिल होंगे।

ध्यान दें कि स्तंभ नाम पहले SELECT कथन में निर्दिष्ट स्तंभ नाम होगा।

यूनियन उदाहरण

निम्नलिखित उदाहरण में, हमें उसी कॉलम में students तालिका से DepartmentId की सूची और department तालिका से DepartmentId की सूची मिलेगी:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION
SELECT DepartmentId FROM Departments;

इससे आपको मिलेगा:

क्वेरी केवल 5 पंक्तियाँ लौटाती है जो अलग-अलग डिपार्टमेंट आईडी मान हैं। पहले मान पर ध्यान दें जो शून्य मान है।

SQLite UNION ALL उदाहरण

निम्नलिखित उदाहरण में, हमें उसी कॉलम में students तालिका से DepartmentId की सूची और department तालिका से DepartmentId की सूची मिलेगी:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION ALL
SELECT DepartmentId FROM Departments;

इससे आपको मिलेगा:

क्वेरी 14 पंक्तियाँ लौटाएगी, 10 पंक्तियाँ students टेबल से और 4 पंक्तियाँ department टेबल से। ध्यान दें कि लौटाए गए मानों में डुप्लिकेट हैं। साथ ही, ध्यान दें कि कॉलम का नाम वही था जो पहले SELECT कथन में निर्दिष्ट किया गया था।

अब, आइए देखें कि यदि हम UNION ALL को UNION से प्रतिस्थापित करें तो UNION all किस प्रकार भिन्न परिणाम देगा:

SQLite एक दूसरे को काटना

दोनों संयुक्त परिणाम सेट में मौजूद मान लौटाता है। संयुक्त परिणाम सेट में से किसी एक में मौजूद मानों को अनदेखा कर दिया जाएगा।

उदाहरण

निम्नलिखित क्वेरी में, हम DepartmentId कॉलम में Students और Departments दोनों तालिकाओं में मौजूद DepartmentId मानों का चयन करेंगे:

SELECT DepartmentId FROM Students
Intersect
SELECT DepartmentId FROM Departments;

इससे आपको मिलेगा:

क्वेरी केवल तीन मान 1, 2 और 3 लौटाती है। ये वे मान हैं जो दोनों तालिकाओं में मौजूद हैं।

हालाँकि, शून्य और 4 मान शामिल नहीं किए गए क्योंकि शून्य मान केवल छात्रों की तालिका में मौजूद है और विभागों की तालिका में नहीं है। और मान 4 विभागों की तालिका में मौजूद है और छात्रों की तालिका में नहीं है।

यही कारण है कि NULL और 4 दोनों मानों को नजरअंदाज कर दिया गया और लौटाए गए मानों में शामिल नहीं किया गया।

के सिवाय

मान लीजिए कि आपके पास पंक्तियों की दो सूचियाँ हैं, सूची 1 और सूची 2, और आप केवल सूची 1 से पंक्तियाँ चाहते हैं जो सूची 2 में मौजूद नहीं हैं, तो आप "EXCEPT" खंड का उपयोग कर सकते हैं। EXCEPT खंड दो सूचियों की तुलना करता है और उन पंक्तियों को लौटाता है जो सूची 1 में मौजूद हैं और सूची 2 में मौजूद नहीं हैं।

उदाहरण

निम्नलिखित क्वेरी में, हम उन DepartmentId मानों का चयन करेंगे जो विभाग तालिका में मौजूद हैं और छात्र तालिका में मौजूद नहीं हैं:

SELECT DepartmentId FROM Departments
EXCEPT
SELECT DepartmentId FROM Students;

इससे आपको मिलेगा:

क्वेरी केवल मान 4 लौटाती है। यह एकमात्र मान है जो विभाग तालिका में मौजूद है, और छात्र तालिका में मौजूद नहीं है।

नल हैंडलिंग

“NULL” मान एक विशेष मान है SQLiteइसका उपयोग अज्ञात या अनुपलब्ध मान को दर्शाने के लिए किया जाता है। ध्यान दें कि नल मान, "0" या रिक्त स्थान से पूरी तरह भिन्न होता है। क्योंकि 0 और रिक्त स्थान ज्ञात मान होते हैं, जबकि नल मान अज्ञात होता है।

NULL मानों को विशेष प्रबंधन की आवश्यकता होती है SQLiteअब हम देखेंगे कि NULL मानों को कैसे संभालना है।

शून्य मानों की खोज करें

आप शून्य मानों को खोजने के लिए सामान्य समानता ऑपरेटर (=) का उपयोग नहीं कर सकते। उदाहरण के लिए, निम्न क्वेरी उन छात्रों की खोज करती है जिनके पास शून्य DepartmentId मान है:

SELECT * FROM Students WHERE DepartmentId = NULL;

यह क्वेरी कोई परिणाम नहीं देगी:

क्योंकि NULL मान किसी अन्य मान के बराबर नहीं होता है जिसमें स्वयं शून्य मान शामिल होता है, इसीलिए इसने कोई परिणाम नहीं दिया।

हालांकि, क्वेरी को काम करने के लिए, आपको शून्य मानों को खोजने के लिए "IS NULL" ऑपरेटर का उपयोग करना होगा, जैसा कि नीचे दिखाया गया है:

SELECT * FROM Students WHERE DepartmentId IS NULL;

इससे आपको मिलेगा:

क्वेरी उन छात्रों को लौटाएगी जिनका DepartmentId मान शून्य है।

यदि आप उन मानों को प्राप्त करना चाहते हैं जो नल नहीं हैं, तो आपको "IS NOT NULL" ऑपरेटर का उपयोग इस प्रकार करना होगा:

SELECT * FROM Students WHERE DepartmentId IS NOT NULL;

इससे आपको मिलेगा:

क्वेरी उन छात्रों को लौटाएगी जिनके पास NULL DepartmentId मान नहीं है।

सशर्त परिणाम

यदि आपके पास मानों की एक सूची है और आप कुछ शर्तों के आधार पर उनमें से किसी एक का चयन करना चाहते हैं, तो उसके लिए उस विशेष मान के लिए शर्त सत्य होनी चाहिए।

CASE अभिव्यक्ति सभी मानों के लिए शर्तों की इन सूची का मूल्यांकन करेगी। यदि शर्त सत्य है, तो यह उस मान को लौटाएगा।

उदाहरण के लिए, यदि आपके पास एक कॉलम “ग्रेड” है और आप ग्रेड मान के आधार पर निम्नलिखित पाठ मान चुनना चाहते हैं:

– “उत्कृष्ट” यदि ग्रेड 85 से अधिक है।

– “बहुत अच्छा” यदि ग्रेड 70 और 85 के बीच है।

– “अच्छा” यदि ग्रेड 60 और 70 के बीच है।

फिर आप ऐसा करने के लिए CASE अभिव्यक्ति का उपयोग कर सकते हैं।

इसका उपयोग SELECT क्लॉज में कुछ तर्क को परिभाषित करने के लिए किया जा सकता है ताकि आप उदाहरण के लिए if स्टेटमेंट जैसी कुछ शर्तों के आधार पर कुछ परिणामों का चयन कर सकें।

CASE ऑपरेटर को निम्नलिखित विभिन्न सिंटैक्स के साथ परिभाषित किया जा सकता है:

आप विभिन्न स्थितियों का उपयोग कर सकते हैं:

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  WHEN condition3 THEN result3
  …
  ELSE resultn
END

या, आप केवल एक अभिव्यक्ति का उपयोग कर सकते हैं और चुनने के लिए विभिन्न संभावित मान रख सकते हैं:

CASE expression
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  WHEN value3 THEN result3
  …
  ELSE restuln
END

ध्यान रखें कि ELSE खंड वैकल्पिक है।

उदाहरण

निम्नलिखित उदाहरण में, हम स्टूडेंट्स टेबल में डिपार्टमेंट आईडी कॉलम में NULL मान के साथ CASE एक्सप्रेशन का उपयोग करके 'कोई विभाग नहीं' टेक्स्ट प्रदर्शित करेंगे, जैसा कि नीचे दिखाया गया है:

SELECT
  StudentName,
  CASE
    WHEN DepartmentId IS NULL THEN 'No Department'
    ELSE DepartmentId
  END AS DepartmentId
FROM Students;

• CASE ऑपरेटर DepartmentId का मान जांचेगा कि वह शून्य है या नहीं।
• यदि यह NULL मान है, तो यह DepartmentId मान के स्थान पर शाब्दिक मान 'No Department' का चयन करेगा।
• यदि शून्य मान नहीं है, तो यह DepartmentId कॉलम का मान चुनेगा.

इससे आपको नीचे दिखाए अनुसार आउटपुट मिलेगा:

सामान्य तालिका अभिव्यक्ति

सामान्य तालिका अभिव्यक्तियाँ (CTE) उपक्वेरी होती हैं जिन्हें SQL कथन के अंदर दिए गए नाम से परिभाषित किया जाता है।

सबक्वेरीज़ की तुलना में इसका एक फायदा यह है कि इसे SQL स्टेटमेंट से अलग परिभाषित किया जाता है और इससे क्वेरीज़ को पढ़ना, बनाए रखना और समझना आसान हो जाता है।

एक सामान्य तालिका अभिव्यक्ति को SELECT कथन के सामने WITH खंड रखकर निम्नानुसार परिभाषित किया जा सकता है:

WITH CTEname
AS
(
   SELECT statement
)
SELECT, UPDATE, INSERT, or update statement here FROM CTE

“CTEname” CTE के लिए दिया गया कोई भी नाम हो सकता है, जिसका उपयोग आप बाद में इसे संदर्भित करने के लिए कर सकते हैं। ध्यान दें कि आप CTE पर SELECT, UPDATE, INSERT या DELETE स्टेटमेंट परिभाषित कर सकते हैं।

अब, आइए एक उदाहरण देखें कि SELECT क्लॉज में CTE का उपयोग कैसे किया जाता है।

उदाहरण

निम्नलिखित उदाहरण में, हम SELECT कथन से CTE परिभाषित करेंगे, और फिर हम बाद में इसे किसी अन्य क्वेरी पर उपयोग करेंगे:

WITH AllDepartments
AS
(
  SELECT DepartmentId, DepartmentName
  FROM Departments
)
SELECT
  s.StudentId,
  s.StudentName,
  a.DepartmentName
FROM Students AS s
INNER JOIN AllDepartments AS a ON s.DepartmentId = a.DepartmentId;

इस क्वेरी में, हमने एक CTE को परिभाषित किया और उसे "AllDepartments" नाम दिया। इस CTE को एक SELECT क्वेरी से परिभाषित किया गया था:

SELECT DepartmentId, DepartmentName
  FROM Departments

फिर जब हमने CTE को परिभाषित कर लिया तो हमने इसका प्रयोग SELECT क्वेरी में किया जो इसके बाद आती है।

ध्यान दें कि, कॉमन टेबल एक्सप्रेशन क्वेरी के आउटपुट को प्रभावित नहीं करते हैं। यह एक तार्किक दृश्य या सबक्वेरी को परिभाषित करने का एक तरीका है ताकि उन्हें उसी क्वेरी में पुनः उपयोग किया जा सके। कॉमन टेबल एक्सप्रेशन एक वैरिएबल की तरह होते हैं जिसे आप घोषित करते हैं, और इसे सबक्वेरी के रूप में पुनः उपयोग करते हैं। केवल SELECT कथन क्वेरी के आउटपुट को प्रभावित करता है।

यह क्वेरी आपको देगी:

उन्नत प्रश्न

उन्नत क्वेरीज़ वे क्वेरीज़ होती हैं जिनमें जटिल जॉइन, सबक्वेरीज़ और कुछ एग्रीगेट्स होते हैं। अगले भाग में हम उन्नत क्वेरी का एक उदाहरण देखेंगे:

हम कहाँ से प्राप्त करते हैं,

• प्रत्येक विभाग के सभी छात्रों के साथ विभाग के नाम
• छात्रों का नाम अल्पविराम से अलग करके
• कम से कम तीन छात्रों वाले विभाग को दर्शाना

SELECT
  d.DepartmentName,
  COUNT(s.StudentId) StudentsCount,
  GROUP_CONCAT(StudentName) AS Students
FROM Departments AS d
INNER JOIN Students AS s ON s.DepartmentId = d.DepartmentId
GROUP BY d.DepartmentName
HAVING COUNT(s.StudentId) >= 3;

हमने डिपार्टमेंट टेबल से डिपार्टमेंट का नाम प्राप्त करने के लिए एक JOIN क्लॉज़ जोड़ा। उसके बाद हमने दो एग्रीगेट फ़ंक्शन के साथ एक GROUP BY क्लॉज़ जोड़ा:

• प्रत्येक विभाग समूह के छात्रों की गिनती करने के लिए “COUNT” का प्रयोग करें।
• GROUP_CONCAT प्रत्येक समूह के छात्रों को एक स्ट्रिंग में अल्पविराम से अलग करके संयोजित करने के लिए।

GROUP BY के बाद, हमने विभागों को फ़िल्टर करने के लिए HAVING क्लॉज़ का उपयोग किया और केवल उन विभागों का चयन किया जिनमें कम से कम 3 छात्र हों।

परिणाम निम्नलिखित होगा:

अक्सर पूछे जाने वाले प्रश्न