SQL Server: Jak dołączyć do pierwszego wiersza

Wiem, że odpowiedź na to pytanie została udzielona jakiś czas temu, ale w przypadku dużych zbiorów danych zagnieżdżone zapytania mogą być kosztowne. Oto inne rozwiązanie, w którym zagnieżdżone zapytanie zostanie uruchomione tylko raz, zamiast dla każdego zwracanego wiersza.

SELECT 
  Orders.OrderNumber,
  LineItems.Quantity, 
  LineItems.Description
FROM 
  Orders
  INNER JOIN (
    SELECT
      Orders.OrderNumber,
      Max(LineItem.LineItemID) AS LineItemID
    FROM
      Orders INNER JOIN LineItems
      ON Orders.OrderNumber = LineItems.OrderNumber
    GROUP BY Orders.OrderNumber
  ) AS Items ON Orders.OrderNumber = Items.OrderNumber
  INNER JOIN LineItems 
  ON Items.LineItemID = LineItems.LineItemID

Możesz zrobić:

SELECT 
  Orders.OrderNumber, 
  LineItems.Quantity, 
  LineItems.Description
FROM 
  Orders INNER JOIN LineItems 
  ON Orders.OrderID = LineItems.OrderID
WHERE
  LineItems.LineItemID = (
    SELECT MIN(LineItemID) 
    FROM   LineItems
    WHERE  OrderID = Orders.OrderID
  )

To wymaga indeksu (lub klucza głównego) na LineItems.LineItemID i indeksu na LineItems.OrderID, w przeciwnym razie będzie to powolne.

@ Quassnoi odpowiedź jest dobra, w niektórych przypadkach (szczególnie jeśli zewnętrzna tabela jest duża), bardziej wydajne zapytanie może być za pomocą funkcji okienkowych, takich jak:

SELECT  Orders.OrderNumber, LineItems2.Quantity, LineItems2.Description
FROM    Orders
LEFT JOIN 
        (
        SELECT  LineItems.Quantity, LineItems.Description, OrderId, ROW_NUMBER()
                OVER (PARTITION BY OrderId ORDER BY (SELECT NULL)) AS RowNum
        FROM    LineItems

        ) LineItems2 ON LineItems2.OrderId = Orders.OrderID And RowNum = 1

Czasami po prostu musisz przetestować które zapytanie daje lepszą wydajność.

Skorelowane zapytania podrzędne To zapytania podrzędne, które zależą od zapytania zewnętrznego. To jak pętla for w SQL. Zapytanie podrzędne uruchomi się raz dla każdego wiersza w zapytaniu zewnętrznym:

select * from users join widgets on widgets.id = (
    select id from widgets
    where widgets.user_id = users.id
    order by created_at desc
    limit 1
)

, Inny aproach używający wyrażenia common table:

with firstOnly as (
    select Orders.OrderNumber, LineItems.Quantity, LineItems.Description, ROW_NUMBER() over (partiton by Orders.OrderID order by Orders.OrderID) lp
    FROM Orders
        join LineItems on Orders.OrderID = LineItems.OrderID
) select *
  from firstOnly
  where lp = 1

A może na koniec chciałbyś pokazać wszystkie połączone wiersze?

Oddzielona przecinkami wersja tutaj:

  select *
  from Orders o
    cross apply (
        select CAST((select l.Description + ','
        from LineItems l
        where l.OrderID = s.OrderID
        for xml path('')) as nvarchar(max)) l
    ) lines

EDIT: nevermind, Quassnoi ma lepszą odpowiedź.

Dla SQL2K, coś takiego:

SELECT 
  Orders.OrderNumber
, LineItems.Quantity
, LineItems.Description
FROM (  
  SELECT 
    Orders.OrderID
  , Orders.OrderNumber
  , FirstLineItemID = (
      SELECT TOP 1 LineItemID
      FROM LineItems
      WHERE LineItems.OrderID = Orders.OrderID
      ORDER BY LineItemID -- or whatever else
      )
  FROM Orders
  ) Orders
JOIN LineItems 
  ON LineItems.OrderID = Orders.OrderID 
 AND LineItems.LineItemID = Orders.FirstLineItemID

Rozwiązuję podobny problem używając LEFT JOIN i GROUP BY Orders.Numer porządkowy. Czy jest jakiś powód, żeby tego nie robić w ten sposób?

SELECT Orders.OrderNumber, LineItems.Quantity, LineItems.Description
FROM Orders
    LEFT JOIN LineItems 
    ON Orders.OrderID = LineItems.OrderID
GROUP BY Orders.OrderNumber

Odpowiem na twoje pytanie z odpowiedzią na twoje własne pytanie:

Orders             LineItems
+-------------+    +---------+----------+---------------+
| OrderNumber |    | OrderID | Quantity | Description   |
+-------------+    +---------+----------+---------------+
| 22586       |    | 22586   | 17       | Trunion       |
+-------------+    | 22586   | 3        | Girdle Spring |
                   +---------+----------+---------------+

Połączenie tych dwóch razem na OrderNumber daje:

OrderNumber  Quantity  Description
-----------  --------  -------------
22586        17        Trunion
22586        3         Girdle Spring

2 row(s) affected

Gdzie chcieliśmy, aby zwrócił tylko jeden wiersz:

OrderNumber  Quantity  Description
-----------  --------  -------------
22586        17        Trunion

1 row(s) affected

Dlatego używam rozkazów GROUP BY.OrderNumber, który zwraca tylko jeden wiersz na OrderNumber.

Moim ulubionym sposobem uruchamiania tego zapytania jest użycie klauzuli not exists. Uważam, że jest to najskuteczniejszy sposób uruchamiania tego typu zapytań:

select o.OrderNumber,
       li.Quantity,
       li.Description
from Orders as o
inner join LineItems as li
on li.OrderID = o.OrderID
where not exists (
    select 1
    from LineItems as li_later
    where li_later.OrderID = o.OrderID
    and li_later.LineItemGUID > li.LineItemGUID
    )

Ale nie testowałem tej metody na tle innych metod sugerowanych tutaj.

Wypróbowałem Krzyż, działa ładnie, ale trwa nieco dłużej. Dostosowano kolumny linii, aby miały max i dodano grupę, która utrzymywała prędkość i upuszczała dodatkowy rekord.

Oto dopasowane zapytanie:

SELECT Orders.OrderNumber, max(LineItems.Quantity), max(LineItems.Description)
FROM Orders
    INNER JOIN LineItems 
    ON Orders.OrderID = LineItems.OrderID
Group by Orders.OrderNumber