SQL
Limpiar código en SQL

Introducción

Formato y ortografía de palabras clave y nombres

Nombres de tabla / columna

Dos formas comunes de formatear nombres de tablas / columnas son CamelCase y snake_case :

SELECT FirstName, LastName
FROM Employees
WHERE Salary > 500;

SELECT first_name, last_name
FROM employees
WHERE salary > 500;

Los nombres deben describir lo que se almacena en su objeto. Esto implica que los nombres de las columnas usualmente deben ser singulares. Si los nombres de tablas deben usar singular o plural es una pregunta muy discutida , pero en la práctica, es más común usar nombres de tablas en plural.

Agregar prefijos o sufijos como tbl o col reduce la legibilidad, así que evítalos. Sin embargo, a veces se utilizan para evitar conflictos con las palabras clave de SQL y, a menudo, con desencadenantes e índices (cuyos nombres no suelen mencionarse en las consultas).

Palabras clave

Las palabras clave de SQL no distinguen entre mayúsculas y minúsculas. Sin embargo, es una práctica común escribirlos en mayúsculas.

SELECCIONAR *

SELECT * devuelve todas las columnas en el mismo orden en que están definidas en la tabla.

Cuando se utiliza SELECT * , los datos devueltos por una consulta pueden cambiar siempre que cambie la definición de la tabla. Esto aumenta el riesgo de que las diferentes versiones de su aplicación o su base de datos sean incompatibles entre sí.

Además, leer más columnas de las necesarias puede aumentar la cantidad de E / S de disco y de red.

Por lo tanto, siempre debe especificar explícitamente la (s) columna (s) que realmente desea recuperar:

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

(Al hacer consultas interactivas, estas consideraciones no se aplican.)

Sin embargo, SELECT * no duele en la subconsulta de un operador EXISTS, porque EXISTS ignora los datos reales de todos modos (solo verifica si se ha encontrado al menos una fila). Por la misma razón, no tiene sentido enumerar ninguna columna específica para EXISTS, por lo que SELECT * realidad tiene más sentido:

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

Sangría

No hay un estándar ampliamente aceptado. En lo que todos estamos de acuerdo es que apretar todo en una sola línea es malo:

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;

Como mínimo, coloque cada cláusula en una nueva línea y divida las líneas si se alargarían demasiado, de lo contrario:

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;

A veces, todo después de la palabra clave SQL que introduce una cláusula está sangrado en la misma columna:

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;

(Esto también puede hacerse alineando las palabras clave de SQL a la derecha).

Otro estilo común es poner palabras clave importantes en sus propias líneas:

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;

La alineación vertical de múltiples expresiones similares mejora la legibilidad:

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

El uso de varias líneas dificulta la incorporación de comandos SQL en otros lenguajes de programación. Sin embargo, muchos idiomas tienen un mecanismo para cadenas de varias líneas, por ejemplo, @"..." en C #, """...""" en Python, o R"(...)" en C ++.

Se une

Siempre se deben utilizar combinaciones explícitas; Las uniones implícitas tienen varios problemas:

• La condición de unión está en algún lugar de la cláusula WHERE, mezclada con cualquier otra condición de filtro. Esto hace que sea más difícil ver qué tablas están unidas y cómo.

• Debido a lo anterior, existe un mayor riesgo de errores y es más probable que se detecten más adelante.

• En SQL estándar, las uniones explícitas son la única forma de usar uniones externas :

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

• Las combinaciones explícitas permiten el uso de la cláusula USING:

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

  (Esto requiere que ambas tablas usen el mismo nombre de columna.
  USAR elimina automáticamente la columna duplicada del resultado, por ejemplo, la unión en esta consulta devuelve una única columna de RecipeID .)