Buenas prácticas de indentación de declaración SQL

coding-style indentation

Question

¿Cuál es la práctica aceptada para sangrar sentencias de SQL? Por ejemplo, considere la siguiente declaración SQL:

SELECT column1, column2
FROM table1
WHERE column3 IN
(
SELECT TOP(1) column4
FROM table2
INNER JOIN table3
ON table2.column1 = table3.column1
)

¿Cómo debe ser sangrado? Muchas gracias.

Answer 1

Acabo de ponerlo a través de mi prettifier SQL y salió así ...

SELECT column1, column2
FROM table1
WHERE column3 IN
(
SELECT TOP(1) column4
FROM table2
INNER JOIN table3
ON table2.column1 = table3.column1
)

http://extras.sqlservercentral.com/prettifier/prettifier.aspx

..... Pero no he encontrado la forma de poner los colores en .

Answer 2

Aquí está mi poke en esto:

select column1, column2
from table1
where (column3 in (
select top(1) column4
from table2
inner join table3
on (table2.column1 = table3.column1)
))
;

• Todo en minúsculas porque es más fácil leer caracteres en minúsculas (y tenemos resaltado de código para enfatizar las palabras clave) también es más fácil escribir
• Cada restricción u opción en una palabra clave (como la de en la selección o el en la unión) se sangra para mostrar su dependencia de la palabra clave externa
• El corchete de cierre tiene el mismo nivel de mellado que la abertura donde
• Use corchetes para las cláusulas where y on para aumentar la legibilidad
• Haga que el punto y coma cierre el enunciado de selección con el mismo sangrado, de modo que se puedan distinguir mejor los enunciados múltiples (si necesita un punto y coma en su idioma, como SAS PROC SQL)
• Todavía es bastante compacto y no se extiende por toda la página

Answer 3

Así es como lo haríamos aquí:

select COLUMN1, COLUMN2, case when COLUMN5 = ''X'' and COLUMN6 = ''Y'' then ''one'' when COLUMN5 in ( ''AAA'', ''BBB'' ) then ''two'' else ''three'' end as COLUMN7 from TABLE1 where COLUMN2 in ( select top(1) COLUMN4 from TABLE2 inner join TABLE3 on TABLE2.COLUMN1 = TABLE3.COLUMN1 and TABLE2.COLUMN2 between TABLE3.COLUMN2 and TABLE3.COLUMN3 )

Nuestra idea es: mantener las palabras clave sql en minúsculas y poner todas las cosas cambiantes (y por lo tanto "más interesantes") como nombres de tablas o columnas en mayúsculas. El código puede parecer un poco "explotado" aquí, pero aumenta la legibilidad si tiene consultas complejas con nombres más largos (incluido el esquema, etc.) mucho más que en este ejemplo. Y: sangra todos los objetos según su "nivel".

Answer 4

Bueno, por supuesto depende de la consulta.

Para consultas simples, un esquema de sangría altamente formal es más un problema de lo que vale y puede hacer que el código sea menos legible, no más. Pero a medida que la complejidad crece, debe comenzar a ser más cuidadoso con la estructura de la declaración, para asegurarse de que será legible nuevamente más adelante.

Answer 5

Como la mayoría de los anteriores han alineado los nombres de las columnas de retorno, encuentro que alinear nombres y condiciones de tablas ayuda mucho a la legibilidad.

SELECT
column1,
column2
FROM
table1
WHERE
column3 IN
(
SELECT TOP(1)
column4
FROM
table2 INNER JOIN
table3 ON table2.column1 = table3.column1
)

Y para cuando las condiciones de unión se alarguen.

SELECT
Column1,
Column2
FROM
Table1 JOIN
Table2 ON
Table1.Column3 = Table2.Column4 JOIN
Table3 ON
Table2.Column1 = Table3.Column1 and
Table2.ColumnX = @x and
Table3.ColumnY = @y
WHERE
Condition1=xxx and
Condition2=yyy and
(
Condition3=aaa or
Condition4=bbb
)

Answer 6

Ejemplo de sangrado de un SQL muy, muy complejo:

SELECT
produtos_cesta.cod_produtos_cesta,
produtos.nome_pequeno,
tab_contagem.cont,
produtos_cesta.sku,
produtos_kits.sku_r AS sku_kit,
sku_final = CASE
WHEN produtos_kits.sku_r IS NOT NULL THEN produtos_kits.sku_r
ELSE produtos_cesta.sku
END,
estoque = CASE
WHEN produtos2.estoque IS NOT NULL THEN produtos2.estoque
ELSE produtos.estoque
END,
produtos_cesta.unidades as unidades1,
unidades_x_quantidade = CASE
WHEN produtos.cod_produtos_kits_tipo = 1 THEN CAST(produtos_cesta.quantidade * (produtos_cesta.unidades / tab_contagem.cont) * produtos_kits.quantidade AS int)
ELSE CAST(produtos_cesta.quantidade * produtos_cesta.unidades AS int)
END,
unidades = CASE
WHEN produtos.cod_produtos_kits_tipo = 1 THEN produtos_cesta.unidades / tab_contagem.cont * produtos_kits.quantidade
ELSE produtos_cesta.unidades
END,
unidades_parent = produtos_cesta.unidades,
produtos_cesta.quantidade,
produtos.controla_estoque,
produtos.status
FROM
produtos_cesta
INNER JOIN produtos
ON (produtos_cesta.sku = produtos.sku)
INNER JOIN produtos_pacotes
ON (produtos_cesta.sku = produtos_pacotes.sku)
INNER JOIN (
SELECT
produtos_cesta.cod_produtos_cesta,
cont = SUM(
CASE
WHEN produtos_kits.quantidade IS NOT NULL THEN produtos_kits.quantidade
ELSE 1
END
)
FROM
produtos_cesta
LEFT JOIN produtos_kits
ON (produtos_cesta.sku = produtos_kits.sku)
LEFT JOIN produtos
ON (produtos_cesta.sku = produtos.sku)
WHERE
shopper_id = ''" + mscsShopperId + @"''
GROUP BY
produtos_cesta.cod_produtos_cesta,
produtos_cesta.sku,
produtos_cesta.unidades
)
AS tab_contagem
ON (produtos_cesta.cod_produtos_cesta = tab_contagem.cod_produtos_cesta)
LEFT JOIN produtos_kits
ON (produtos.sku = produtos_kits.sku)
LEFT JOIN produtos as produtos2
ON (produtos_kits.sku_r = produtos2.sku)
WHERE
shopper_id = ''" + mscsShopperId + @"''
GROUP BY
produtos_cesta.cod_produtos_cesta,
tab_contagem.cont,
produtos_cesta.sku,
produtos_kits.sku_r,
produtos.cod_produtos_kits_tipo,
produtos2.estoque,
produtos.controla_estoque,
produtos.estoque,
produtos.status,
produtos.nome_pequeno,
produtos_cesta.unidades,
produtos_cesta.quantidade,
produtos_kits.quantidade
ORDER BY
produtos_cesta.sku,
produtos_cesta.unidades DESC

Answer 7

El formateo de SQL es un área donde hay una gran cantidad de desacuerdos ... Pero me gusta enfocarme en la legibilidad y pensar que sea lo que sea que hagas, cumplir con las reglas que reducen la legibilidad es, como dice el viejo cliché, una "consistencia insensata" ("Consistencia absurda es un duende para las mentes simples")

Entonces, en lugar de llamarlos reglas, aquí hay algunas pautas. Para cada cláusula importante en una declaración SQL (Seleccionar, Insertar, Eliminar, De, Dónde, Tener, Agrupar POR, Ordenar Por, ... Me pueden faltar algunas) debe ser FÁCILMENTE identificable. Así que generalmente los guiones al más alto nivel, todos incluso entre ellos. Luego, dentro de cada cláusula, sangro la siguiente subestructura lógica de manera uniforme ... y así sucesivamente ... Pero me siento libre de (y a menudo lo hago) cambiar el patrón si en algún caso individual sería más fácil hacerlo ... Las declaraciones complejas de Case son un buen ejemplo. Como cualquier cosa que requiera desplazamiento horizontal reduce enormemente la legibilidad, a menudo escribo expresiones complejas (anidadas) en varias líneas. Cuando lo hago, trato de mantener el comienzo de dicha instrucción colgando sangría en función de su lugar lógico en la declaración SQL, y sangro el resto de las líneas de declaración de algunos caracteres furthur ...

El código de la base de datos SQL ha existido durante mucho tiempo, ya que antes las computadoras tenían minúsculas, por lo que existe una preferencia histórica por las palabras clave de mayúsculas, pero prefiero la legibilidad a la tradición ... (y cada herramienta que uso códigos de color las palabras clave ahora de todas formas)

También utilizaría alias de tabla para reducir la cantidad de texto que el ojo tiene que escanear para asimilar la estructura de la consulta, siempre que los alias no creen confusión. En una consulta con menos de 3 o 4 tablas, los alias de caracteres únicos están bien, a menudo uso la primera letra de la tabla si todas las tablas comienzan con una letra diferente ... nuevamente, lo que sea que más contribuya a la legibilidad. Finalmente, si su base de datos lo admite, muchas de las palabras clave son opcionales (como "Interno", "Externo", "Como" para alias, etc.) "Into" (de Insert Into) es opcional en el servidor Sql, pero no en Oracle). Tenga cuidado al usar esto si su código necesita ser independiente de la plataforma ...

Tu ejemplo, escribiría como:

Select column1, column2
From table1 T1
Where column3 In (Select Top(1) column4
From table2 T2
Join table3 T3
On T2.column1 = T3.column1)

O

Select column1, column2
From table1 T1
Where column3 In
(Select Top(1) column4
From table2 T2
Join table3 T3
On T2.column1 = T3.column1)

Si hay muchas más columnas en la cláusula select, doblaría la segunda línea y las posteriores ... En general, NO me atengo a ninguna regla estricta (una columna por fila) ya que el desplazamiento es casi tan malo para la legibilidad como el desplazamiento horizontal es, especialmente si solo las primeras diez columnas de la pantalla tienen texto en ellas)

Select column1, column2, Col3, Col4, column5,
column6, Column7, isNull(Column8, ''FedEx'') Shipper,
Case Upper(Column9)
When ''EAST'' Then ''JFK''
When ''SOUTH'' Then ''ATL''
When ''WEST'' Then ''LAX''
When ''NORTH'' Then ''CHI'' End HubPoint
From table1 T1
Where column3 In
(Select Top(1) column4
From table2 T2
Join table3 T3
On T2.column1 = T3.column1)

Formatee el código de la manera que sea más legible ...

Answer 8

Esta es mi preferencia normal:

....SELECT column1
........,column2
....FROM table1
....WHERE column3 IN (
........SELECT TOP(1) column4
........FROM table2
........INNER JOIN table3
............ON table2.column1 = table3.column1
....)

Aunque el confunde el formateo con un espacio extra, así que pongo algunos períodos para que pueda ver el formato real ...

Answer 9

Esta es una cuestión de gusto.

Esta es mi preferencia.

SELECT
column1
,column2
FROM
table1
WHERE column3 IN (
SELECT TOP(1) column4
FROM
table2
INNER JOIN table3
ON table2.column1 = table3.column1
)

Answer 10

Este enlace es el mejor que encontré. http://www.sqlinform.com/free_online_sw.html

Answer 11

Este es mi método personal. Dependiendo de la duración de la condición de unión, a veces la sangro en la línea de abajo.

SELECT
column1,
column2
FROM
table1
WHERE
column3 IN (
SELECT TOP(1)
column4
FROM
table2
INNER JOIN table3 ON table2.column1 = table3.column1
)
SELECT
column1,
column2
FROM
table1
WHERE
column3 IN (
SELECT TOP(1)
column4
FROM
table2
INNER JOIN table3
ON table2.column1 = table3.column1 -- for long ones
)

Answer 12

Formatearía así:

SELECT
column1,
column2
FROM
table1
WHERE
column3 IN (SELECT TOP(1)
column4
FROM
table2
INNER JOIN table3 ON table2.column1 = table3.column1)

o así:

SELECT
column1,
column2
FROM
table1
WHERE
column3 IN (SELECT TOP(1) column4
FROM table2
INNER JOIN table3 ON table2.column1 = table3.column1)

Answer 13

He escrito un estándar de código para nuestra tienda que está sesgado en extremo hacia la legibilidad / "descubrimiento" (este último es principalmente útil en las instrucciones de inserción-selección):

SELECT
column1,
column2
FROM
table1
WHERE
column3 IN
(
SELECT TOP(1)
column4
FROM
table2
INNER JOIN table3 ON table2.column1 = table3.column1
)

En consultas más complejas se vuelve más obvio cómo esto es útil:

SELECT
Column1,
Column2,
Function1
(
Column1,
Column2
) as Function1,
CASE
WHEN Column1 = 1 THEN
a
ELSE
B
END as Case1
FROM
Table1 t1
INNER JOIN Table2 t2 ON t1.column12 = t2.column21
WHERE
(
FilterClause1
AND FilterClause2
)
OR
(
FilterClause3
AND FilterClause4
)

Una vez que te mueves a sistemas con más de una sola combinación en la mayoría de tus consultas, mi experiencia me dice que usar el espacio vertical liberalmente es tu mejor amigo con SQL complejo.

Answer 14

Lo que suelo hacer es

print("SELECT column1, column2
FROM table1
WHERE column3 IN (SELECT TOP(1) column4
FROM table2 INNER JOIN
table3 ON table2.column1 = table3.column1)");

Answer 15

Me gusta la forma de jalbert de alinear las palabras clave a su derecha. También agregaría que me gustan los AND y los quirófanos de la izquierda (algunas personas los ponen a la derecha). Además, me gusta alinear mis signos iguales siempre que sea posible.

SELECT column1,
column2
FROM table1, table2
WHERE table1.column1 = table2.column4
AND table1.col5 = "hi"
OR table2.myfield = 678

Answer 16

Me gusta que las diferentes partes de mi consulta se alineen verticalmente. Tiendo a usar un tamaño de tabulación de 8 espacios para SQL que parece funcionar bien.

SELECT column1,
column2
FROM table1
WHERE column3 IN
(
SELECT TOP(1) column4
FROM table2
INNER JOIN table3
ON table2.column1 = table3.column1
)

Answer 17

Me gusta tener "ríos" de espacios en blanco en el código. Hace que sea un poco más fácil de escanear.

SELECT column1,
column2
FROM table1
WHERE column3 IN (SELECT column4
FROM table2
JOIN table3
ON table2.column1 = table3.column1);

Answer 18

No estoy seguro de que haya una práctica aceptada, pero ahora cómo lo haría:

SELECT
column1,
column2
FROM
table1
WHERE
column3 IN
(
SELECT TOP(1)
column4
FROM
table2
INNER JOIN
table3
ON table2.column1 = table3.column1
)

Answer 19

No sé si hay un estándar, pero me gusta hacerlo de esta manera;

SELECT column1, column2
FROM table1
WHERE column3 IN
(
SELECT TOP(1) column4
FROM table2
INNER JOIN table3
ON table2.column1 = table3.column1
)

porque puedo leer y analizar el SQL mejor.

Answer 20

Por supuesto, esto se reduce a las preferencias personales. Y si se trata de un equipo, es algo que debería acordarse entre los miembros por motivos de coherencia. Pero esta sería mi preferencia:

SELECT column1, column2
FROM table1
WHERE column3 IN(SELECT TOP(1) column4
FROM table2
INNER JOIN table3 ON
table2.column1 = table3.column1
)

Answer 21

Sí, esto es bastante subjetivo ... Pero aquí están mis 2 centavos:

SELECT
Column1,
Column2
FROM Table1
WHERE
Column3 IN (
SELECT Column4
FROM Table2
JOIN Table3 ON
Table2.Column1 = Table3.Column1
)

Pero, en realidad, probablemente lo reescribiera sin el IN:

SELECT
Column1,
Column2
FROM Table1
JOIN Table2 ON
Table1.Column3 = Table2.Column4
JOIN Table3 ON
Table2.Column1 = Table3.Column1

Básicamente, mis reglas son:

• Capitalizar palabras clave
• Las columnas van en líneas individuales, pero los modificadores SELECT (SELECT TOP 100, SELECT DISTINCT, etc.) o las columnas individuales (SELECT 1, SELECT Id, SELECT *, etc.) van en la misma línea
• Unir condiciones sangrado debajo cláusula JOIN
• Use JOIN para INNER JOIN (ya que es el más común), y especifique completamente otros (LEFT OUTER JOIN, FULL OUTER JOIN, etc.)
• Abra parens en la misma línea, cierre la página en una línea separada. Si tiene un alias, el alias va con paren cercano.

Answer 22

Si tiene una larga declaración de SQL que le gustaría volver a formatear sin todo el tipeo y tabulación, puede golpearlo en este sitio web y obtener un resultado muy formateado. Puede experimentar con varios formatos para ver cuál hace que su texto sea más legible.

Editar: creo que this es la ubicación 2014 del formateador SQL.

Answer 23

SELECT
Column1,
Column2
FROM
Table1
WHERE
Column3 IN
(
SELECT TOP (1)
Column4
FROM
Table2
INNER JOIN
Table3
ON
Table2.Column1 = Table3.Column1
)

Answer 24

SELECT column1
, column2
FROM table1
WHERE column3 IN
(
SELECT TOP(1) column4
FROM table2
INNER JOIN table3
ON table2.column1 = table3.column1
)

Me gusta tener todo "," al frente , así nunca los busco cuando hay un error en la línea X del editor de SQL.

Este es un ejemplo para aquellos que no usan este tipo de instrucción SQL de escritura. Ambos contienen un error de una coma faltante.

SELECT sdcolumn123
, dscolumn234
, sdcolumn343
, ffcolumn434
, sdcolumn543
, bvcolumn645
vccolumn754
, cccolumn834
, vvcolumn954
, cvcolumn104
FROM table1
WHERE column3 IN
(
...
)
SELECT sdcolumn123, dscolumn234, asdcolumn345, dscolumn456, ascolumn554, gfcolumn645 sdcolumn754, fdcolumn845, sdcolumn954, fdcolumn1054
FROM table1
WHERE column3 IN
(
...
)

Encontré más fácil y más rápido en el primer ejemplo. Espero que este ejemplo te muestre más mi punto de vista.

Answer 25

SELECT column1, column2
FROM table
WHERE column3 IN (
SELECT TOP(1) column4
FROM table2
INNER JOIN table3 ON table2.column1 = table3.column1
)

Esto es bastante corto y fácil de leer. Haría ajustes si hubiera más columnas seleccionadas o más condiciones de unión.