Wcięcie w instrukcji SQL dobra praktyka [zamknięte]

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

To jest dość krótkie i łatwe do odczytania. Dokonałbym korekt, gdyby wybrano więcej kolumn lub więcej warunków łączenia.

Nie jestem pewien czy istnieje akceptowana praktyka, ale oto jak bym to zrobił:

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

Lubię mieć "rzeki" Białej spacji w kodzie. Ułatwia to skanowanie.

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

Podoba mi się forma jalberta ułożenia słów kluczowych po prawej stronie. Dodam jeszcze, że lubię ANDs i ORs po lewej stronie (niektórzy umieszczają je po prawej.) Ponadto Lubię ustawiać swoje znaki równości, gdy jest to możliwe.

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

To moja osobista metoda. W zależności od długości warunku łączenia czasami wciskam go na poniższej linii.

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
  )

Napisałem standard kodu dla naszego sklepu, który jest stronniczy w skrajnym kierunku czytelności/ "odkrywalności" (ta ostatnia jest przede wszystkim przydatna w wyrażeniach insert-select):

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

Przy bardziej złożonych zapytaniach staje się bardziej oczywiste, jak jest to przydatne:

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
    )

Po przejściu do systemów z więcej niż jednym połączeniem w większości zapytań, z mojego doświadczenia wynika, że korzystanie z pionowej przestrzeni liberalnie jest twoim najlepszym przyjacielem ze złożonym SQL.

Jeśli masz długie polecenie SQL, które chcesz sformatować bez wpisywania i zakładania kart, możesz umieścić je w na tej stronie i uzyskać ładnie sformatowany wynik. Możesz eksperymentować z różnymi formatami, aby zobaczyć, co sprawia, że tekst jest najbardziej czytelny.

Edit: wierzę, że to {[2] } jest lokalizacją 2014 formatera SQL.

Formatowanie SQL jest obszarem, w którym istnieje wiele wariancji i nieporozumień... Ale fwiw, Lubię skupiać się na czytelności i myślę, że cokolwiek robisz, konsekwentne przestrzeganie wszelkich zasad, które zmniejszają czytelność, jest, jak mówi Stary banał, "głupią konsekwencją" ("głupia konsystencja jest hobgoblinem dla prostych umysłów") {]}

Więc zamiast nazywać je regułami, oto kilka wskazówek. Dla każdej głównej klauzuli w instrukcji SQL (Select, Insert, Delete, From, Where, Having, Group BY, Order By,... Może brakuje kilku) powinny być łatwo rozpoznawalne. Więc generalnie wciąłem je na najwyższym poziomie, wszystkie nawet ze sobą. Następnie w ramach każdej klauzuli równomiernie wcinam następną logiczną podbudowę... i tak dalej.. Ale czuję się swobodnie (i często) zmienić wzór, jeśli w każdym indywidualnym przypadku byłoby to bardziej czytelne... Dobrym przykładem są złożone deklaracje przypadków. Ponieważ wszystko co wymaga poziomego przewijania ogromnie zmniejsza czytelność, często zapisuje złożone (zagnieżdżone) wyrażenia Case w wielu wierszach. Kiedy to robię, staram się, aby początek takiego polecenia zawieszał się na podstawie jego logicznego miejsca w instrukcji SQL, a resztę wierszy instrukcji wcięło kilka znaków dalej...

Kod bazy danych SQL istnieje od dawna, odkąd komputery miały małe litery, więc istnieje historyczna preferencja dla słów kluczowych o górnej obudowie, ale wolę czytelność niż tradycję... (i każde narzędzie używam kodów kolorów słowa kluczowe teraz w każdym razie)

Użyłbym również aliasów tabel, aby zmniejszyć ilość tekstu, który oko musi skanować, aby poprawić strukturę zapytania, o ile aliasy nie powodują zamieszania. W zapytaniu z mniej niż 3 lub 4 tabel aliasy pojedynczych znaków są w porządku, często używam pierwszej litery tabeli, jeśli wszystkie tabele zaczynają się od innej litery... ponownie, co najbardziej przyczynia się do czytelności. Wreszcie, jeśli twoja baza danych GO obsługuje, wiele słów kluczowych to opcjonalne (np." Wewnętrzne"," Zewnętrzne"," As " dla aliasów itp.) "Into" (od Insert Into) jest opcjonalne na Sql Server-ale nie na Oracle) więc uważaj na używanie tego, jeśli twój kod musi być niezależny od platformy...

Twój przykład, napiszę jako:

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

Lub

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

Jeśli w klauzuli select jest więcej kolumn, wciąłbym drugą i kolejne linie... Generalnie nie przestrzegam żadnych ścisłych (jedna kolumna w wierszu) reguł, ponieważ przewijanie veritcally jest prawie tak źle dla czytelności, jak przewijanie w poziomie, zwłaszcza jeśli tylko pierwsze dziesięć kolumn ekranu ma w sobie tekst)

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)

Sformatuj kod w dowolny sposób, który czyni go najbardziej czytelnym...

Lubię mieć różne części mojego zapytania w linii pionowej. Zazwyczaj używam tabulatora o rozmiarze 8 spacji dla SQL, który wydaje się działać dobrze.

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

Przykład wcięć bardzo bardzo skomplikowanego 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

Jak większość powyżej ustawiła nazwy kolumn zwrotnych, uważam, że ustawianie nazw tabel i warunków bardzo pomaga w czytelności.

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

I gdy warunki przyłączenia się są długie.

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
    )

Oczywiście sprowadza się to do osobistych preferencji. A jeśli w zespole, to jest coś, co powinno być uzgodnione między członkami ze względu na spójność. Ale to by było moje preferencje:

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

Oto mój poke na to:

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

• Wszystko małe litery, ponieważ łatwiej jest odczytać małe znaki (i mamy podświetlanie kodu, aby podkreślić słowa kluczowe) również łatwiej jest wpisać
• każde ograniczenie lub opcja na słowie kluczowym (jak from na select lub on na join) jest wcięta, aby pokazać ich zależność od słowa kluczowego outward
• wspornik zamykający znajduje się na tym samym poziomie wcięcia, co otwór, gdzie
• Użyj nawiasów dla klauzul where - I on-do zwiększ czytelność
• średnik zamyka polecenie select w tym samym wcięciu, dzięki czemu można lepiej rozróżnić wiele instrukcji (jeśli potrzebujesz średnika w swoim języku, tak jak SAS PROC SQL)
• jest nadal dość kompaktowy i nie rozciąga się na całej stronie

Sformatowałbym TAK:

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

Lub tak:

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

To moje normalne preferencje:

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

Chociaż stackoverflow psuje formatowanie z dodatkową spacją wiodącą, więc wstawiłem kilka okresów, abyś mógł zobaczyć rzeczywiste formatowanie...

Właśnie wrzuciłem to do mojego SQL prettifier i wyszło tak....

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

.....Ale nie wypracowałem sposobu na wprowadzenie kolorów do StackOverflow.

Tak, to dość subiektywne...Ale oto moje 2 grosze:

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

Ale, naprawdę, pewnie bym to przepisał bez IN:

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

Zasadniczo moje zasady to:

• Wielkimi Literami Słowa Kluczowe
• kolumny idą po poszczególnych liniach, ale wybierz modyfikatory (wybierz TOP 100, Wybierz DISTINCT, itp.) lub pojedyncze kolumny (SELECT 1, SELECT Id, SELECT *, itd.) przejdź do tej samej linii
• warunki przyłączenia wcięte pod klauzulą przyłączenia
• użyj JOIN dla wewnętrznego JOIN (ponieważ jest wspólne), i w pełni określić inne (LEFT OUTER JOIN, FULL OUTER JOIN, itp.)
• Otwórz paren na tej samej linii, Zamknij paren na oddzielnej linii. Jeśli masz alias, alias idzie z close paren.

Ten link jest najlepszy jaki znalazłem. http://www.sqlinform.com/free_online_sw.html

Cóż, oczywiście to zależy od zapytania.

Dla prostych zapytań, wysoce formalny schemat wcięć jest po prostu więcej kłopotu niż jest wart i może sprawić, że kod będzie mniej czytelny, a nie więcej. Ale wraz ze wzrostem złożoności musisz zacząć bardziej uważać na to, jak ustrukturyzujesz oświadczenie, aby upewnić się, że będzie ono ponownie czytelne później.

Nie wiem czy jest jakiś standard ale lubię to robić w ten sposób;

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

Ponieważ potrafię lepiej czytać i analizować SQL.

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

To co zwykle robię to,

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

To kwestia gustu.

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

Tak byśmy to zrobili tutaj:

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
        )

Naszym pomysłem jest: zachowaj słowa kluczowe sql w małych literach i umieść wszystkie zmieniające się (a więc "bardziej interesujące") rzeczy, takie jak nazwy tabel lub kolumn w wielkich literach. Kod może wyglądać nieco "wysadzony" tutaj, ale zwiększa czytelność, jeśli masz złożone zapytania o dłuższych nazwach (w tym. schemat itp.) znacznie dłużej niż w tym przykładzie. Oraz: wcięcie wszystkich obiektów zgodnie z ich "poziomem".