मूल SQL क्वेरी

इस आलेख में मूल SQL क्वेरी के उदाहरण हैं जिनका उपयोग शुरुआती अपने डेटाबेस से डेटा पुनर्प्राप्त करने के लिए कर सकते हैं।

मूल SELECT प्रश्न

SQL में संभवतः सबसे अधिक उपयोग की जाने वाली क्वेरी का एक उदाहरण यहां दिया गया है:

SELECT * 
FROM Pets;

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+

यह क्वेरी Pets . से सभी पंक्तियों और सभी स्तंभों का चयन करती है टेबल। ऐसा इसलिए है क्योंकि तारांकन (* ) वाइल्डकार्ड सभी स्तंभों का चयन करता है।

कॉलम नाम चुनें

प्रदर्शन कारणों से, आमतौर पर सभी स्तंभों का चयन करने से बचना सबसे अच्छा होता है, जब तक कि आपको वास्तव में उनकी आवश्यकता न हो। आमतौर पर केवल उन स्तंभों का चयन करना बेहतर होता है जिनकी आपको आवश्यकता होती है।

यहाँ एक उदाहरण है।

SELECT PetId, PetName
FROM Pets;

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 2       | Fetch     |
| 3       | Scratch   |
| 4       | Wag       |
| 5       | Tweet     |
| 6       | Fluffy    |
| 7       | Bark      |
| 8       | Meow      |
+---------+-----------+

परिणाम फ़िल्टर करें

आप एक WHERE जोड़ सकते हैं परिणामों को केवल उन पंक्तियों में फ़िल्टर करने के लिए क्लॉज जो आपको चाहिए।

SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 6       | Fluffy    |
+---------+-----------+

परिणामों को फ़िल्टर करने का एक और उदाहरण यहां दिया गया है। इस बार हम ऑपरेटर से अधिक का उपयोग करते हैं (> ) इसे तिथि के अनुसार फ़िल्टर करने के लिए।

SELECT PetName, DOB 
FROM Pets
WHERE DOB > '2020-01-01';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

आप अधिक से अधिक ऑपरेटर को अन्य ऑपरेटरों से स्वैप कर सकते हैं, जैसे कि ऑपरेटर से बड़ा या उसके बराबर (>= ), ऑपरेटर से कम (< ), या ऑपरेटर से कम या उसके बराबर (<= )

आप BETWEEN का भी उपयोग कर सकते हैं परिणामों को एक विशिष्ट श्रेणी (जैसे दो तिथियों के बीच) में फ़िल्टर करने के लिए ऑपरेटर।

SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';

परिणाम:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

परिणाम क्रमबद्ध करें

आप एक ORDER BY जोड़ सकते हैं क्वेरी द्वारा लौटाई गई पंक्तियों को सॉर्ट करने के लिए क्लॉज।

आरोही क्रम

ASC का उपयोग करें परिणामों को आरोही क्रम में क्रमबद्ध करने के लिए कीवर्ड। यह डिफ़ॉल्ट मान है, इसलिए यदि आप परिणाम आरोही क्रम में चाहते हैं तो आप इस कीवर्ड को भी छोड़ सकते हैं।

SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;

या:

SELECT PetId, PetName
FROM Pets
ORDER BY PetName;

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+

अवरोही क्रम

DESC का उपयोग करें परिणामों को अवरोही क्रम में क्रमबद्ध करने के लिए कीवर्ड।

SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 4       | Wag       |
| 5       | Tweet     |
| 3       | Scratch   |
| 8       | Meow      |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 2       | Fetch     |
| 7       | Bark      |
+---------+-----------+

एकाधिक कॉलम के आधार पर छाँटें

आप प्रत्येक स्तंभ को अल्पविराम से अलग करके सूचीबद्ध करके एकाधिक स्तंभों के आधार पर क्रमित कर सकते हैं।

SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;

SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+
(8 rows affected)
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 6       | Fluffy    |
| 1       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+
(8 rows affected)

हम देख सकते हैं कि प्रत्येक परिणाम में दो Fluffys एक अलग क्रम हैं (हम उनके PetId को देखकर बता सकते हैं। मान)। ऐसा इसलिए है क्योंकि PetName कॉलम को पहले सॉर्ट किया गया था, फिर PetId पहली छँटाई से किसी भी डुप्लिकेट को सॉर्ट किया गया।

छिपे हुए कॉलम के अनुसार क्रमित करें

आप उन स्तंभों के आधार पर छाँट सकते हैं जो SELECT . में शामिल नहीं हैं सूची।

SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 5       | Tweet     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 4       | Wag       |
| 2       | Fetch     |
| 3       | Scratch   |
| 7       | Bark      |
| 8       | Meow      |
+---------+-----------+

इस मामले में, हम इन परिणामों से यह अनुमान लगा सकते हैं कि Tweet सबसे छोटा पालतू जानवर है, और Meow सबसे पुराना है। ऐसा इसलिए है क्योंकि हमने उनकी जन्मतिथि (DOB .) के अनुसार क्रमित किया है ) कॉलम अवरोही क्रम में।

बस सुनिश्चित करने के लिए, यहाँ यह फिर से DOB . के साथ है SELECT . में शामिल कॉलम सूची।

SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 5       | Tweet     | 2020-11-28 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 4       | Wag       | 2020-03-15 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

दरअसल, अब हम देख सकते हैं कि म्याऊ और बार्क के पास NULL है DOB . में मान कॉलम। इसलिए, हम नहीं जानते कि वे वास्तव में बड़े हैं या छोटे।

लेकिन यह दर्शाता है कि NULL मूल्यों को न्यूनतम संभव मूल्यों के रूप में माना जाता है। NULL . से सावधान रहें क्वेरी चलाते समय मान.

पैटर्न मिलान

आप LIKE . का उपयोग कर सकते हैं पैटर्न मिलान का उपयोग करने के लिए ऑपरेटर।

SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';

परिणाम:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 2       | Fetch     |
| 6       | Fluffy    |
+---------+-----------+

इस उदाहरण में, हम उन सभी पालतू जानवरों की खोज करते हैं जिनके नाम F . अक्षर से शुरू होते हैं . प्रतिशत चिह्न (% ) एक वाइल्डकार्ड वर्ण है जो शून्य या अधिक वर्णों की किसी भी स्ट्रिंग से मेल खाता है। इसका उपयोग उपसर्ग या प्रत्यय के रूप में किया जा सकता है, और इसका उपयोग स्ट्रिंग के बीच में भी किया जा सकता है।

यहाँ एक और उदाहरण है।

SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';

परिणाम:

+-------------+------------+-------------------+
| FirstName   | LastName   | Email             |
|-------------+------------+-------------------|
| Homer       | Connery    | [email protected] |
| Bart        | Pitt       | [email protected]  |
+-------------+------------+-------------------+

सूची से चुनें

IN ऑपरेटर यह निर्धारित करता है कि निर्दिष्ट मान किसी सबक्वेरी या सूची में किसी भी मान से मेल खाता है या नहीं।

यहाँ एक उदाहरण है।

SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 4       | Wag       | 2020-03-15 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

सबक्वायरी

आप IN . का उपयोग कर सकते हैं सबक्वेरी करते समय ऑपरेटर (किसी अन्य क्वेरी के अंदर नेस्टेड क्वेरी)।

यहाँ एक उदाहरण है।

SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );

परिणाम:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
+-------------+-----------+

यह एक टेबल से कॉलम लौटाता है (PetTypes ), लेकिन केवल तभी जब किसी अन्य तालिका में कम से कम एक संगत पंक्ति हो (Pets ) जिसका PetTypeId . से मेल खाता हो कॉलम।

इसे और अधिक प्रदर्शित करने के लिए, इन दो तालिकाओं की प्रासंगिक सामग्री नीचे दिखाई गई है।

PetTypes तालिका:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+

Pets तालिका:

+-------------+-----------+
| PetTypeId   | PetName   |
|-------------+-----------|
| 2           | Fluffy    |
| 3           | Fetch     |
| 2           | Scratch   |
| 3           | Wag       |
| 1           | Tweet     |
| 3           | Fluffy    |
| 3           | Bark      |
| 2           | Meow      |
+-------------+-----------+

हम देख सकते हैं कि PetTypes तालिका में एक पालतू प्रकार का Rabbit होता है , लेकिन Pets . में कोई भी पालतू जानवर नहीं है तालिका को उस प्रकार का असाइन किया गया है (अर्थात 4 . का कोई मान नहीं है Pets.PetTypeId . में कॉलम)।

SQL में ऑपरेटरों के बारे में अधिक जानकारी के लिए 12 सामान्य रूप से प्रयुक्त SQL ऑपरेटर और SQL ऑपरेटरों की यह सूची देखें।

जुड़ता है

यह बहस का विषय है कि क्या SQL जॉइन को "बेसिक SQL क्वेरीज़" माना जाता है, लेकिन मैं वैसे भी यहाँ जॉइन शामिल करूँगा।

तो इस लेख को समाप्त करने के लिए, यहां एक आंतरिक जुड़ाव का उदाहरण दिया गया है।

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

परिणाम:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

इस मामले में, हमने INNER JOIN . का उपयोग किया है सभी पालतू जानवरों के नाम उनके संबंधित पालतू जानवरों के प्रकार के साथ वापस करने के लिए। हमने ON . का इस्तेमाल किया शामिल पंक्तियों की प्रत्येक जोड़ी के लिए मूल्यांकन किए जाने वाले विधेय को निर्दिष्ट करने के लिए खंड। इस मामले में, p.PetTypeId कॉलम pt.PetTypeId . की एक विदेशी कुंजी है कॉलम, जो कि PetTypes . के लिए प्राथमिक कुंजी है टेबल।

इस उदाहरण में, मैंने टेबल पर उपनामों का भी इस्तेमाल किया, जिससे कोड को अच्छा और संक्षिप्त रखने में मदद मिली।

जुड़ने के अधिक उदाहरणों के लिए मेरा SQL Joins Tutorial देखें।