SQL
SQL में क्लीन कोड

परिचय

कीवर्ड और नामों का प्रारूपण और वर्तनी

तालिका / स्तंभ नाम

स्वरूपण तालिका / स्तंभ नामों के दो सामान्य तरीके हैं CamelCase और snake_case :

SELECT FirstName, LastName
FROM Employees
WHERE Salary > 500;

SELECT first_name, last_name
FROM employees
WHERE salary > 500;

नामों का वर्णन करना चाहिए कि उनकी वस्तु में क्या संग्रहीत है। इसका तात्पर्य यह है कि स्तंभ नाम आमतौर पर एकवचन होना चाहिए। क्या तालिका के नामों को एकवचन या बहुवचन का उपयोग करना चाहिए, एक भारी चर्चा वाला प्रश्न है, लेकिन व्यवहार में, बहुवचन तालिका नामों का उपयोग करना अधिक सामान्य है।

tbl या col जैसे उपसर्गों या प्रत्ययों को जोड़ने से पठनीयता कम हो जाती है, इसलिए उनसे बचें। हालांकि, उनका उपयोग कभी-कभी SQL कीवर्ड के साथ टकराव से बचने के लिए किया जाता है, और अक्सर ट्रिगर्स और इंडेक्स के साथ उपयोग किया जाता है (जिनके नाम आमतौर पर प्रश्नों में वर्णित नहीं हैं)।

कीवर्ड

SQL कीवर्ड केस संवेदी नहीं हैं। हालांकि, उन्हें ऊपरी मामले में लिखना आम बात है।

चुनते हैं *

SELECT * सभी स्तंभों को उसी क्रम में लौटाता है जैसे वे तालिका में परिभाषित किए गए हैं।

SELECT * का उपयोग करते समय, क्वेरी द्वारा लौटाया गया डेटा जब भी टेबल की परिभाषा बदलता है, बदल सकता है। इससे यह जोखिम बढ़ जाता है कि आपके एप्लिकेशन या आपके डेटाबेस के विभिन्न संस्करण एक-दूसरे के साथ असंगत हैं।

इसके अलावा, आवश्यकता से अधिक कॉलम पढ़ने से डिस्क और नेटवर्क I / O की मात्रा बढ़ सकती है।

इसलिए आपको हमेशा उस कॉलम को स्पष्ट रूप से निर्दिष्ट करना चाहिए जिसे आप वास्तव में प्राप्त करना चाहते हैं:

--SELECT *                                 don't
  SELECT ID, FName, LName, PhoneNumber  -- do
  FROM Emplopees;

(इंटरएक्टिव प्रश्न करते समय, ये विचार लागू नहीं होते हैं।)

हालाँकि, SELECT * किसी EXISTS ऑपरेटर की अधीनता में चोट नहीं करता है, क्योंकि EXISTS वास्तविक डेटा को वैसे भी अनदेखा करता है (यह केवल तभी जाँच करता है जब कम से कम एक पंक्ति मिली हो)। इसी कारण से, EXISTS के लिए किसी विशिष्ट कॉलम को सूचीबद्ध करना सार्थक नहीं है, इसलिए SELECT * वास्तव में अधिक जानकारी देता है:

-- list departments where nobody was hired recently
SELECT ID,
       Name
FROM Departments
WHERE NOT EXISTS (SELECT *
                  FROM Employees
                  WHERE DepartmentID = Departments.ID
                    AND HireDate >= '2015-01-01');

इंडेंट

कोई व्यापक रूप से स्वीकृत मानक नहीं है। हर कोई इस बात से सहमत है कि सब कुछ एक ही लाइन में निचोड़ना बुरा है:

SELECT d.Name, COUNT(*) AS Employees FROM Departments AS d JOIN Employees AS e ON d.ID = e.DepartmentID WHERE d.Name != 'HR' HAVING COUNT(*) > 10 ORDER BY COUNT(*) DESC;

कम से कम, प्रत्येक खंड को एक नई पंक्ति में डालें, और यदि वे बहुत लंबे समय तक अन्यथा हो जाते हैं, तो लाइनों को विभाजित करें:

SELECT d.Name,
       COUNT(*) AS Employees
FROM Departments AS d
JOIN Employees AS e ON d.ID = e.DepartmentID
WHERE d.Name != 'HR'
HAVING COUNT(*) > 10
ORDER BY COUNT(*) DESC;

कभी-कभी, SQL कीवर्ड द्वारा एक क्लॉज को प्रस्तुत करने के बाद सब कुछ उसी कॉलम का संकेत होता है:

SELECT   d.Name,
         COUNT(*) AS Employees
FROM     Departments AS d
JOIN     Employees AS e ON d.ID = e.DepartmentID
WHERE    d.Name != 'HR'
HAVING   COUNT(*) > 10
ORDER BY COUNT(*) DESC;

(यह सही एसक्यूएल कीवर्ड को संरेखित करते समय भी किया जा सकता है।)

एक और आम शैली महत्वपूर्ण कीवर्ड को अपनी तर्ज पर रखना है:

SELECT
    d.Name,
    COUNT(*) AS Employees
FROM
    Departments AS d
JOIN
    Employees AS e
    ON d.ID = e.DepartmentID
WHERE
    d.Name != 'HR'
HAVING
    COUNT(*) > 10
ORDER BY
    COUNT(*) DESC;

कई समान भावों को अनुलंब रूप से संरेखित करने से पठनीयता में सुधार होता है:

SELECT Model,
       EmployeeID
FROM Cars
WHERE CustomerID = 42
  AND Status     = 'READY';

कई लाइनों का उपयोग करना SQL कमांड को अन्य प्रोग्रामिंग भाषाओं में एम्बेड करना कठिन बनाता है। हालाँकि, कई भाषाओं में मल्टी लाइन स्ट्रिंग्स के लिए एक तंत्र है, उदाहरण के लिए, @"..." # @"..." C # में, """...""" पायथन में, या R"(...)" C ++ में। R"(...)"

में शामिल

स्पष्ट जोड़ हमेशा उपयोग किए जाने चाहिए; निहित जोड़ में कई समस्याएं हैं:

• ज्वाइन की स्थिति कहीं न कहीं WHERE क्लॉज में है, जिसे किसी भी अन्य फिल्टर की स्थिति के साथ मिलाया गया है। इससे यह देखना कठिन हो जाता है कि कौन सी तालिकाएँ शामिल हुई हैं, और कैसे।

• उपरोक्त के कारण, गलतियों का एक उच्च जोखिम है, और यह अधिक संभावना है कि वे बाद में पाए जाते हैं।

• मानक SQL में, स्पष्ट जुड़ाव बाहरी जोड़ का उपयोग करने का एकमात्र तरीका है:

  SELECT d.Name,
         e.Fname || e.LName AS EmpName
  FROM      Departments AS d
  LEFT JOIN Employees   AS e ON d.ID = e.DepartmentID;
  

• स्पष्ट जुड़ाव का उपयोग करते हुए अनुमति देता है:

  SELECT RecipeID,
         Recipes.Name,
         COUNT(*) AS NumberOfIngredients
  FROM      Recipes
  LEFT JOIN Ingredients USING (RecipeID);
  

  (इसके लिए आवश्यक है कि दोनों तालिकाएँ समान स्तंभ नाम का उपयोग करें।
  उपयोग करने से स्वचालित रूप से डुप्लिकेट कॉलम को परिणाम से हटा दिया जाता है, उदाहरण के लिए, इस क्वेरी में शामिल होने से एक एकल RecipeID कॉलम RecipeID है।)