Código limpio en SQL

Para escribir consultas SQL legibles y de calidad, como ejemplos de buenas prácticas. Ejemplos  de formato y ortografía de palabras clave y nombres de tablas y columnas:

SELECT Nombre, Apellido FROM Empleados WHERE Salario > 500;

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

Agregar prefijos o sufijos como tbl o col reduce la legibilidad, por lo que se deben evitar. Sin embargo, a veces se usan para evitar conflictos con palabras clave de SQL y, a menudo, se usan con activadores e índices (cuyos nombres generalmente no se mencionan 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 escribirlas en mayúsculas. 

SELECT * 

devuelve todas las columnas en el mismo orden en que están definidas en la tabla. Al usar 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 nuestra aplicación y nuestra 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 red. Por tanto, siempre debemos especificar explícitamente las columnas que realmente deseamos recuperar:

 SELECT ID, Nombre, Apellido1, Apellido2, N_Telefono FROM Empleados;

(Al realizar consultas interactivas, estas consideraciones no se aplican). Sin embargo, SELECT * no daña 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 columnas específicas para EXISTS, por lo que SELECT * en realidad tiene más sentido en este caso concreto: 

Ejemplo: enumerar los departamentos en los que no se contrató a nadie recientemente 

SELECT ID, Nombre FROM Departamentos WHERE NOT EXISTS (SELECT * FROM Empleados WHERE IDDepartamento = Departmento.ID AND FechaContrato >= '2015-01-01'); 

No existe un estándar ampliamente aceptado sobre las sangrías. En lo que todos están de acuerdo es en que meter todo en una sola línea es malo. Como mínimo, colocaremos cada cláusula en una nueva línea y dividiremos las líneas si se vuelven demasiado largas.

A veces, todo lo que sigue a la palabra clave SQL que introduce una cláusula se sangra en la misma columna: 

SELECT d.Nombre,

COUNT(*) AS Empleados

FROM Departamentos AS d

JOIN Empleados AS e ON d.ID = e.DepartamentoID

WHERE d.Nombre != 'HR'

HAVING COUNT(*) > 10

ORDER BY COUNT(*) DESC;

Esto también se puede hacer mientras se alinean correctamente las palabras clave de SQL. Otro estilo común es colocar palabras clave importantes en sus propias líneas: 

SELECT

d.Nombre,

COUNT(*) AS Empleados

FROM

Departamentos AS d

JOIN

Empleados AS e

ON d.ID = e.DepartamentoID

WHERE

d.Nombre != 'HR'

HAVING

COUNT(*) > 10

ORDER BY

COUNT(*) DESC;

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

SELECT Modelo, IDEmpleado 

FROM Coches 

WHERE IDCliente = 42 

AND Status = 'Listo'; 

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

JOINS

Siempre se deben utilizar uniones 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 se unen y cómo. Debido a lo anterior, existe un mayor riesgo de errores y es más probable que se encuentren más tarde.  En SQL estándar, las uniones explícitas son la única forma de utilizar uniones externas: 

SELECT d.Nombre, e.FNombre || e.LNombre AS EmpNombre 

FROM Departamentos AS d 

LEFT JOIN Empleados AS e ON d.ID = e.IDDepartamento; 

Las uniones explícitas permiten usar la cláusula USING: 

SELECT IDReceta, Receta.Nombre,  COUNT(*) AS NumeroDeIngredientes 

FROM Recetas

LEFT JOIN Ingredientes USING (IDReceta); 

(Esto requiere que ambas tablas usen el mismo nombre de columna. USING elimina automáticamente la columna duplicada del resultado, p. ej., la unión en esta consulta devuelve una sola columna IDReceta).