Передовой опыт использования отступов в SQL-запросах

Это мой личный метод. В зависимости от длины условия соединения я иногда делаю отступ в строке ниже.

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
  )

SELECT column1, column2
FROM table
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 
    )

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

Мне нравится иметь все "," спереди, поэтому я никогда не ищу их, когда появляется ошибка в строке X редактора SQL.

Это пример для тех, кто не использует этот тип написания операторов SQL. Оба содержат ошибку отсутствия запятой.

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
(
    ...
)

На первом примере я нашел проще и быстрее. Надеюсь, этот пример лучше отражает мою точку зрения.

Что я обычно делаю,

print("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
                 )

Я бы отформатировал так:

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)

Я не знаю, есть ли стандарт, но мне нравится делать это таким образом;

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

потому что я лучше умею читать и анализировать SQL.

Мне нравится, когда в коде есть «реки» белого пространства. Это немного упрощает сканирование.

SELECT column1,
       column2
  FROM table1
 WHERE column3 IN (SELECT column4
                     FROM table2
                     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
    )

Это дело вкуса.

Это мое предпочтение.

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

Мне нравится, когда разные части моего запроса выстраиваются вертикально. Я обычно использую размер табуляции 8 пробелов для SQL, который, кажется, работает хорошо.

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

Ну, конечно, это зависит от запроса.

Для простых запросов очень формальная схема отступов создает больше проблем, чем она того стоит, и может фактически сделать код меньше читабельным, не более того. Но по мере роста сложности вам нужно быть более осторожным с тем, как вы структурируете оператор, чтобы убедиться, что его снова можно будет прочитать позже.

Да, это довольно субъективно ... Но вот мои 2 цента:

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

Но, на самом деле, я бы, наверное, переписал его без IN:

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

В основном мои правила таковы:

• Использовать заглавные буквы в ключевых словах
• Столбцы располагаются в отдельных строках, но модификаторы SELECT (SELECT TOP 100, SELECT DISTINCT и т. д.) Или отдельные столбцы (SELECT 1, SELECT Id, SELECT * и т. д.) Располагаются в той же строке.
• Условия соединения с отступом под предложением JOIN
• Используйте JOIN для INNER JOIN (поскольку он является общим) и полностью укажите другие (LEFT OUTER JOIN, FULL OUTER JOIN и т. д.)
• Раскройте скобки на той же строке, закройте скобки на отдельной строке. Если у вас есть псевдоним, псевдоним идет с закрытым пареном.

Форматирование SQL - это область, в которой существует много разногласий и разногласий ... Но, черт возьми, мне нравится сосредотачиваться на удобочитаемости и думать, что все, что вы делаете, последовательное соответствие любым правилам, снижающим читаемость, - это, как гласит старое клише, "глупая последовательность" ("Глупая последовательность - хобгоблин для простых умов")

Итак, вместо того, чтобы называть их правилами, вот несколько рекомендаций. Для каждого основного предложения в операторе SQL (Select, Insert, Delete, From, Where, Have, Group BY, Order By, ... Мне может не хватать нескольких) должно быть ЛЕГКО идентифицируемое. Так что я обычно делаю отступы на самом высоком уровне, даже между собой. Затем в каждом предложении я равномерно делаю отступ для следующей логической подструктуры ... и так далее ... Но я не стесняюсь (и часто делаю) изменить шаблон, если в каждом отдельном случае это было бы более читабельно ... Сложные операторы Case - хороший пример. Поскольку все, что требует горизонтальной прокрутки, сильно снижает удобочитаемость, я часто пишу сложные (вложенные) выражения Case в несколько строк. Когда я это делаю, я стараюсь, чтобы начало такого оператора оставалось висящим отступом на основе его логического места в операторе SQL, и делаю отступ для остальных строк оператора на несколько символов дальше ...

Код базы данных SQL существует уже давно, так как до того, как компьютеры имели нижний регистр, исторически предпочтение было отдано ключевым словам в верхнем регистре, но я предпочитаю удобочитаемость традициям ... (и теперь каждый инструмент, который я использую, цветовой кодирует ключевые слова в любом случае)

Я бы также использовал псевдонимы таблиц, чтобы уменьшить объем текста, который глаз должен сканировать, чтобы разобраться в структуре запроса, если псевдонимы не создают путаницы. В запросе с менее чем 3 или 4 таблицами односимвольные псевдонимы подходят, я часто использую первую букву таблицы, если все таблицы начинаются с другой буквы ... опять же, что больше всего способствует удобочитаемости. Наконец, если ваша база данных поддерживает это, многие ключевые слова являются необязательными (например, «Inner», «Outer», «As» для псевдонимов и т. д.) «Into» (из Insert Into) является необязательным для Sql Server, но не на Oracle) Так что будьте осторожны при использовании этого, если ваш код должен быть независимым от платформы ...

Ваш пример я бы написал как:

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

Или же

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

Если в предложении select намного больше столбцов, я бы сделал отступ для второй и последующих строк ... Обычно я НЕ придерживаюсь каких-либо строгих правил (один столбец на строку), поскольку прокрутка по вертикали почти так же плоха для удобочитаемости, как и прокрутка по горизонтали есть, особенно если только первые десять столбцов экрана содержат текст)

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)

Отформатируйте код так, чтобы он был максимально читаемым ...

Мне нравится, как Jalbert выстраивает ключевые слова справа от них. Я также добавлю, что мне нравятся операторы И и ИЛИ слева (некоторые ставят их справа). Кроме того, мне нравится выстраивать свои знаки равенства, когда это возможно.

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

Я написал стандарт кода для нашего магазина, который предвзято относится к удобочитаемости / "обнаруживаемости" (последнее в первую очередь полезно в операторах insert-select):

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,
    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
    )

После того, как вы перейдете к системам с более чем одним соединением в большинстве ваших запросов, мой опыт показывает, что свободное вертикальное пространство - ваш лучший друг со сложным SQL.

Если у вас есть длинный оператор SQL, который вы хотите переформатировать без ввода текста и табуляции, вы можете вставить его в этот сайт и получить хорошо отформатированный результат. Вы можете поэкспериментировать с различными форматами, чтобы увидеть, какой из них делает ваш текст наиболее читаемым.

Обновлено: я считаю, что это - это расположение модуля форматирования SQL в 2014 году.

Я только что пропустил это через свой SQL prettifier, и получилось вот так ...

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

..... Но я не придумал способ переноса цветов в StackOverflow.

Пример отступа очень-очень сложного SQL:

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

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
    )

И когда условия присоединения становятся длинными.

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
    )

Вот как мы это сделаем здесь:

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
        )

Наша идея: сохранять ключевые слова sql в нижнем регистре и помещать все изменяющиеся (и, следовательно, «более интересные») вещи, такие как имена таблиц или столбцов, в верхний регистр. Код может выглядеть здесь немного "взорванным", но он увеличивает читаемость, если у вас есть сложные запросы с более длинными именами (включая схему и т. д.), Намного более длинными, чем в этом примере. И: сделайте отступ для всех объектов в соответствии с их «уровнем».

Вот мой тычок по этому поводу:

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

• Все строчные буквы, потому что строчные символы легче читать (и у нас есть подсветка кода, чтобы выделить ключевые слова), также легче вводить
• Каждое ограничение или параметр ключевого слова (например, от при выборе или включение при соединении) имеет отступ, чтобы показать их зависимость от ключевого слова outward.
• Закрывающая скобка находится на том же уровне отступа, что и открывающая, где
• Используйте скобки для предложений where и on, чтобы повысить удобочитаемость
• Поместите точку с запятой, закрывающую оператор select с одним и тем же отступом, чтобы несколько операторов можно было лучше различать (если вам нужна точка с запятой на вашем языке, как это делает SAS PROC SQL)
• Он по-прежнему довольно компактен и не растягивается по всей странице.