SQL
Ren kod i SQL

Introduktion

Formatering och stavning av nyckelord och namn

Tabell / kolumnnamn

Två vanliga sätt att formatera tabeller / kolumnnamn är CamelCase och snake_case :

SELECT FirstName, LastName
FROM Employees
WHERE Salary > 500;

SELECT first_name, last_name
FROM employees
WHERE salary > 500;

Namnen ska beskriva vad som finns lagrat i deras objekt. Detta innebär att kolumnnamn vanligtvis ska vara singular. Huruvida tabellnamn ska använda singular eller plural är en mycket diskuterad fråga, men i praktiken är det vanligare att använda plural tabellnamn.

Att lägga till prefix eller suffix som tbl eller col minskar läsbarheten, så undvik dem. Men de används ibland för att undvika konflikter med SQL-nyckelord och används ofta med triggers och index (vars namn vanligtvis inte nämns i frågor).

Nyckelord

SQL-nyckelord är inte skiftlägeskänsliga. Det är dock vanligt att skriva dem med stora bokstäver.

VÄLJ *

SELECT * returnerar alla kolumner i samma ordning som de definieras i tabellen.

När du använder SELECT * kan data som returneras av en fråga ändras när tabelldefinitionen ändras. Detta ökar risken för att olika versioner av din applikation eller din databas är oförenliga med varandra.

Vidare kan läsning av fler kolumner än nödvändigt öka mängden disk och nätverk I / O.

Så du bör alltid uttryckligen ange den eller de kolumner du faktiskt vill hämta:

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

(När du gör interaktiva frågor gäller dessa överväganden inte.)

SELECT * skadar emellertid inte i undersökningen hos en EXISTS-operatör, eftersom EXISTS ignorerar de faktiska uppgifterna ändå (det kontrolleras bara om åtminstone en rad har hittats). Av samma anledning är det inte meningsfullt att lista några specifika kolumner för EXISTER, så SELECT * verkligen mer meningsfullt:

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

indrag

Det finns ingen allmänt accepterad standard. Vad alla är överens om är att det är dåligt att pressa allt i en enda linje:

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;

Sätt åtminstone varje klausul i en ny rad och dela rader om de skulle bli för långa annars:

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;

Ibland är allt efter SQL-nyckelordet som introducerar en klausul indraget i samma 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;

(Detta kan också göras när SQL-nyckelorden riktas in.)

En annan vanlig stil är att sätta viktiga nyckelord på sina egna linjer:

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;

Justering av flera liknande uttryck vertikalt förbättrar läsbarheten:

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

Att använda flera rader gör det svårare att bädda in SQL-kommandon i andra programmeringsspråk. Men många språk har en mekanism för flersträngssträngar, t.ex. @"..." i C #, """...""" i Python eller R"(...)" i C ++.

Fogar

Explicit samverkan bör alltid användas; implicita sammanfogningar har flera problem:

• Kopplingsvillkoret är någonstans i WHERE-klausulen, blandat med andra filtervillkor. Detta gör det svårare att se vilka tabeller som sammanfogas och hur.

• På grund av ovanstående finns det en högre risk för misstag och det är mer troligt att de hittas senare.

• I standard SQL är uttryckliga sammanfogningar det enda sättet att använda yttre förbindelser :

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

• Explicit anslutningar tillåter att använda USING-klausulen:

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

  (Detta kräver att båda tabellerna använder samma kolumnnamn.
  ANVÄNDNING tar automatiskt bort dubblettkolumnen från resultatet, t.ex. kopplingen i den här frågan returnerar en enda RecipeID kolumn.)