SQL Отступ в хорошей практике

Какова принятая практика для отступов SQL-предложений? Например, рассмотрим следующий оператор SQL:

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

Как это сделать? Большое спасибо.

Ответ 1

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

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

Ответ 2

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

Это довольно короткий и удобный для чтения. Я бы внес коррективы, если было больше выбранных столбцов или больше условий соединения.

Ответ 3

Не уверен, что есть принятая практика, но вот теперь, как бы я это сделал:

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

Ответ 4

Мне нравится иметь "реки" белого пространства в коде. Это облегчает сканирование.

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

Ответ 5

Мне нравится jalbert форму выравнивания ключевых слов справа. Я также добавлю, что мне нравятся AND и OR слева (некоторые люди помещают их справа). Кроме того, мне нравится выравнивать свои знаки равенства, когда это возможно.


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

Ответ 6

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

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
  )

Ответ 7

Я написал код для нашего магазина, который крайне предвзято к читабельности/ "открытости" (последний в первую очередь полезен для операторов 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.

Ответ 8

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

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

Ответ 9

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

Итак, вместо того, чтобы называть их правилами, вот некоторые рекомендации. Для каждого предложения Major в выражении SQL (выбор, вставка, удаление, из, где, наличие, группа BY, порядок,... возможно, некоторые из них) должны быть ЛЕГКО идентифицируемыми. Поэтому я вообще отступаю их на самом высоком уровне, все даже друг с другом. Затем в каждом предложении я равномерно откладываю следующую логическую подструктуру... и т.д. Но я не стесняюсь (и часто делаю) изменять шаблон, если в каком-либо отдельном случае было бы более читаемым сделать это... Хорошим примером являются примеры сложных случаев. Поскольку все, что требует горизонтальной прокрутки, чрезвычайно упрощает чтение, я часто пишу сложные (вложенные) выражения Case на несколько строк. Когда я это делаю, я пытаюсь сохранить начало такого утверждения, зависающего отступа на основе его логического места в выражении SQL, и отступ остальных строк строки несколько символов furthur...

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

Я также использовал бы псевдонимы таблиц, чтобы уменьшить количество текста, которое глаз должен сканировать, чтобы получить структуру запроса, до тех пор, пока псевдонимы не создают путаницу. В запросе с менее чем тремя или четырьмя таблицами односимвольные псевдонимы в порядке, я часто использую первую букву таблицы, если все эти таблицы начинаются с другой буквы... снова, независимо от того, что вносит вклад в удобочитаемость. Наконец, если ваша база данных поддерживает ее, многие ключевые слова являются необязательными (например, "Внутренний", "Внешний", "Как" для псевдонимов и т.д.). "Into" (из Insert Into) является необязательным на сервере Sql, но не на 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 есть еще много столбцов, я бы отложил вторую и последующие строки... Я вообще НЕ придерживаюсь какого-либо строкового правила (один столбец на строку), так как прокрутка veritcally почти так же плохо для читаемости как прокрутка по горизонтали, особенно если только первые десять столбцов экрана имеют какой-либо текст в них)

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)

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

Ответ 10

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

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

Ответ 11

Пример отступы очень очень сложного 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

Ответ 12

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

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
    )

Ответ 13

Конечно, это сводится к личным предпочтениям. И если в командной обстановке это должно быть согласовано между членами для согласования. Но это было бы моим преимуществом:

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

Ответ 14

Вот мои слова:

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

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

Ответ 15

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

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)

Ответ 16

Это мое обычное предпочтение:

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

Хотя stackoverflow испортил форматирование с дополнительным ведущим пространством, поэтому я помещаю несколько периодов, чтобы вы могли видеть фактическое форматирование...

Ответ 17

Да, это довольно субъективно... Но вот мои 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 и т.д.).
Открыть парсеры на одной строке, закрыть паз на отдельной строке. Если у вас есть псевдоним, псевдоним идет с близким париком.

Ответ 18

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

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.

Ответ 19

Эта ссылка является лучшей, которую я нашел. http://www.sqlinform.com/free_online_sw.html

Ответ 20

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

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

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

Ответ 21

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

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

Ответ 22

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

Ответ 23

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

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

Ответ 24

Это вопрос вкуса.

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

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

Ответ 25

Что мы будем делать здесь:

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 в нижнем регистре и поместить все изменяющиеся (и, следовательно, "более интересные" ) вещи, такие как имена таблиц или столбцов в верхнем регистре. Код может выглядеть немного "взорван" здесь, но он повышает читаемость, если у вас есть сложные запросы с более длинными именами (включая схему и т.д.) Намного дольше, чем в этом примере. И: отступы всех объектов в соответствии с их "уровнем".