SQL
Wyczyść kod w SQL

Wprowadzenie

Formatowanie i pisownia słów kluczowych i nazw

Nazwy tabel / kolumn

Dwa popularne sposoby formatowania nazw tabel / kolumn to CamelCase i snake_case :

SELECT FirstName, LastName
FROM Employees
WHERE Salary > 500;

SELECT first_name, last_name
FROM employees
WHERE salary > 500;

Nazwy powinny opisywać, co jest przechowywane w ich obiekcie. Oznacza to, że nazwy kolumn zwykle powinny być pojedyncze. To, czy nazwy tabel powinny używać liczby pojedynczej, czy mnogiej, jest szeroko dyskutowanym pytaniem, ale w praktyce częściej stosuje się nazwy tabel mnogich.

Dodanie przedrostków lub przyrostków, takich jak tbl lub col zmniejsza czytelność, więc ich unikaj. Są one jednak czasami stosowane w celu uniknięcia konfliktów ze słowami kluczowymi SQL, a często są używane z wyzwalaczami i indeksami (których nazwy zwykle nie są wymienione w zapytaniach).

Słowa kluczowe

W słowach kluczowych SQL nie jest rozróżniana wielkość liter. Jednak powszechną praktyką jest pisanie ich dużymi literami.

WYBIERZ *

SELECT * zwraca wszystkie kolumny w tej samej kolejności, w jakiej są zdefiniowane w tabeli.

Podczas korzystania z SELECT * dane zwracane przez zapytanie mogą ulec zmianie przy każdej zmianie definicji tabeli. Zwiększa to ryzyko niezgodności różnych wersji aplikacji lub bazy danych.

Co więcej, odczyt większej liczby kolumn niż to konieczne może zwiększyć ilość dyskowych i sieciowych operacji we / wy.

Dlatego zawsze powinieneś jawnie określać kolumny, które chcesz pobrać:

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

(Podczas wykonywania interaktywnych zapytań powyższe uwagi nie mają zastosowania).

Jednak SELECT * nie szkodzi w podzapytaniu operatora EXISTS, ponieważ EXISTS i tak ignoruje rzeczywiste dane (sprawdza tylko, czy znaleziono co najmniej jeden wiersz). Z tego samego powodu nie ma sensu wymieniać żadnych konkretnych kolumn dla ISTNIEJĄCYCH, więc SELECT * faktycznie ma większy sens:

-- 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');

Wcięcie

Nie ma powszechnie akceptowanego standardu. Wszyscy zgadzają się, że ściśnięcie wszystkiego w jedną linię jest złe:

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;

Co najmniej umieść każdą klauzulę w nowej linii i podziel linie, jeśli w przeciwnym razie stałyby się zbyt długie:

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;

Czasami wszystko po słowie SQL wprowadzającym klauzulę jest wcięte w tę samą kolumnę:

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;

(Można to również zrobić, wyrównując odpowiednio słowa kluczowe SQL).

Innym powszechnym stylem jest umieszczanie ważnych słów kluczowych we własnych wierszach:

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;

Wyrównanie w pionie wielu podobnych wyrażeń poprawia czytelność:

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

Korzystanie z wielu wierszy utrudnia osadzanie poleceń SQL w innych językach programowania. Jednak wiele języków ma mechanizm ciągów wieloliniowych, np. @"..." w języku C #, """...""" w języku Python lub R"(...)" w języku C ++.

Łączy się

Zawsze należy stosować wyraźne sprzężenia; Połączenia niejawne mają kilka problemów:

• Warunek łączenia jest gdzieś w klauzuli WHERE, pomieszany z innymi warunkami filtrowania. Utrudnia to sprawdzenie, które tabele są połączone i jak.

• W związku z powyższym istnieje większe ryzyko błędów i istnieje większe prawdopodobieństwo, że zostaną one później odnalezione.

• W standardowym języku SQL połączenia jawne są jedynym sposobem użycia połączeń zewnętrznych :

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

• Jawne sprzężenia pozwalają na użycie klauzuli USING:

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

  (Wymaga to, aby obie tabele używały tej samej nazwy kolumny.
  USING automatycznie usuwa zduplikowaną kolumnę z wyniku, np. RecipeID w tym zapytaniu zwraca pojedynczą kolumnę RecipeID ).