SQL
Bereinigen Sie Code in SQL

Einführung

Formatierung und Schreibweise von Schlüsselwörtern und Namen

Tabellen- / Spaltennamen

Zwei gängige Methoden zum Formatieren von Tabellen- / Spaltennamen sind CamelCase und snake_case :

SELECT FirstName, LastName
FROM Employees
WHERE Salary > 500;

SELECT first_name, last_name
FROM employees
WHERE salary > 500;

Namen sollten beschreiben, was in ihrem Objekt gespeichert ist. Dies bedeutet, dass die Spaltennamen normalerweise singulär sein sollten. Ob Tabellennamen Singular oder Plural verwenden sollen, ist eine viel diskutierte Frage. In der Praxis werden jedoch häufig Tabellennamen verwendet.

Das Hinzufügen von Präfixen oder Suffixen wie tbl oder col verringert die Lesbarkeit. Vermeiden Sie sie. Sie werden jedoch manchmal verwendet, um Konflikte mit SQL-Schlüsselwörtern zu vermeiden, und werden häufig mit Triggern und Indizes (deren Namen in Abfragen normalerweise nicht erwähnt werden) verwendet.

Schlüsselwörter

SQL-Schlüsselwörter unterscheiden nicht zwischen Groß- und Kleinschreibung. Es ist jedoch üblich, sie in Großbuchstaben zu schreiben.

WÄHLEN *

SELECT * gibt alle Spalten in der Reihenfolge zurück, in der sie in der Tabelle definiert sind.

Bei Verwendung von SELECT * können sich die von einer Abfrage zurückgegebenen Daten ändern, wenn sich die Tabellendefinition ändert. Dies erhöht das Risiko, dass verschiedene Versionen Ihrer Anwendung oder Ihrer Datenbank nicht miteinander kompatibel sind.

Wenn Sie mehr Spalten als nötig lesen, kann dies die Anzahl der Festplatten- und Netzwerk-E / A erhöhen.

Daher sollten Sie immer explizit die Spalten angeben, die Sie tatsächlich abrufen möchten:

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

(Bei interaktiven Abfragen gelten diese Überlegungen nicht.)

SELECT * schadet jedoch nicht in der Unterabfrage eines EXISTS-Operators, da EXISTS die tatsächlichen Daten trotzdem ignoriert (es wird nur geprüft, ob mindestens eine Zeile gefunden wurde). Aus demselben Grund ist es nicht sinnvoll, eine bestimmte Spalte für EXISTS aufzulisten. Daher ist SELECT * eigentlich sinnvoller:

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

Einrücken

Es gibt keinen allgemein akzeptierten Standard. Alle sind sich einig, dass es schlecht ist, alles in eine einzige Zeile zu quetschen:

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;

Setzen Sie mindestens jede Klausel in eine neue Zeile und teilen Sie die Zeilen auf, wenn sie sonst zu lang werden würden:

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;

Manchmal wird alles nach dem SQL-Schlüsselwort, das eine Klausel einführt, in dieselbe Spalte eingerückt:

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;

(Dies ist auch möglich, wenn Sie die SQL-Schlüsselwörter richtig ausrichten.)

Ein anderer verbreiteter Stil besteht darin, wichtige Schlüsselwörter in die eigenen Zeilen zu setzen:

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;

Durch das vertikale Ausrichten mehrerer ähnlicher Ausdrücke wird die Lesbarkeit verbessert:

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

Die Verwendung mehrerer Zeilen erschwert das Einbetten von SQL-Befehlen in andere Programmiersprachen. Viele Sprachen haben jedoch einen Mechanismus für mehrzeilige Zeichenfolgen, z. B. @"..." in C #, """...""" in Python oder R"(...)" in C ++.

Schließt sich an

Explizite Joins sollten immer verwendet werden. implizite Joins haben mehrere Probleme:

• Die Join-Bedingung befindet sich irgendwo in der WHERE-Klausel, gemischt mit allen anderen Filterbedingungen. Dies macht es schwieriger zu erkennen, welche Tabellen wie miteinander verbunden werden.

• Aus diesen Gründen besteht ein höheres Fehlerrisiko, und es ist wahrscheinlicher, dass sie später gefunden werden.

• In Standard-SQL sind explizite Joins die einzige Möglichkeit, äußere Joins zu verwenden :

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

• Explizite Joins erlauben die Verwendung der USING-Klausel:

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

  (Dies erfordert, dass beide Tabellen denselben Spaltennamen verwenden.
  USING entfernt automatisch die doppelte Spalte aus dem Ergebnis, z. B. gibt der Join in dieser Abfrage eine einzelne RecipeID Spalte zurück.)