Jak dołączyć do pierwszego rzędu

Wykorzystam konkretny, ale hipotetyczny przykład.

Każde zamówienie ma zwykle tylko jeden element zamówienia :

Zamówienia:

OrderGUID   OrderNumber
=========   ============
{FFB2...}   STL-7442-1      
{3EC6...}   MPT-9931-8A

LineItems:

LineItemGUID   Order ID Quantity   Description
============   ======== ========   =================================
{098FBE3...}   1        7          prefabulated amulite
{1609B09...}   2        32         spurving bearing

Ale czasami będzie zamówienie z dwoma elementami:

LineItemID   Order ID    Quantity   Description
==========   ========    ========   =================================
{A58A1...}   6,784,329   5          pentametric fan
{0E9BC...}   6,784,329   5          differential girdlespring 

Zwykle podczas wyświetlania zamówień użytkownikowi:

SELECT Orders.OrderNumber, LineItems.Quantity, LineItems.Description
FROM Orders
    INNER JOIN LineItems 
    ON Orders.OrderID = LineItems.OrderID

Chcę pokazać pojedynczy element na zamówieniu. Ale z tego okazjonalne zamówienie zawierające dwa (lub więcej) elementów, zamówienia będą pojawiać być powielany :

OrderNumber   Quantity   Description
===========   ========   ====================
STL-7442-1    7          prefabulated amulite
MPT-9931-8A   32         spurving bearing
KSG-0619-81   5          panametric fan
KSG-0619-81   5          differential girdlespring

Naprawdę chcę, aby SQL Server wybrał jeden , ponieważ będzie wystarczająco dobry :

OrderNumber   Quantity   Description
===========   ========   ====================
STL-7442-1    7          prefabulated amulite
MPT-9931-8A   32         differential girdlespring
KSG-0619-81   5          panametric fan

Jeśli zacznę przygodę, mogę pokazać użytkownikowi elipsę, która wskazuje, że jest więcej niż jeden:

OrderNumber   Quantity   Description
===========   ========   ====================
STL-7442-1    7          prefabulated amulite
MPT-9931-8A   32         differential girdlespring
KSG-0619-81   5          panametric fan, ...

Pytanie brzmi: jak to zrobić?

• wyeliminuj „zduplikowane” wiersze
• dołącz tylko do jednego z wierszy, aby uniknąć powielania

Pierwsze podejscie

Moja pierwsza naiwna próba polegała na dołączeniu tylko do elementów zamówienia „ TOP 1 ”:

SELECT Orders.OrderNumber, LineItems.Quantity, LineItems.Description
FROM Orders
    INNER JOIN (
       SELECT TOP 1 LineItems.Quantity, LineItems.Description
       FROM LineItems
       WHERE LineItems.OrderID = Orders.OrderID) LineItems2
    ON 1=1

Ale to daje błąd:

Kolumna lub przedrostek „Zamówienia” nie są
zgodne z nazwą tabeli lub nazwą aliasu
użytą w zapytaniu.

Prawdopodobnie dlatego, że wewnętrzny wybór nie widzi tabeli zewnętrznej.

SELECT   Orders.OrderNumber, LineItems.Quantity, LineItems.Description
FROM     Orders
JOIN     LineItems
ON       LineItems.LineItemGUID =
         (
         SELECT  TOP 1 LineItemGUID 
         FROM    LineItems
         WHERE   OrderID = Orders.OrderID
         )

W SQL Server 2005 i powyżej, można po prostu zastąpić INNER JOINz CROSS APPLY:

SELECT  Orders.OrderNumber, LineItems2.Quantity, LineItems2.Description
FROM    Orders
CROSS APPLY
        (
        SELECT  TOP 1 LineItems.Quantity, LineItems.Description
        FROM    LineItems
        WHERE   LineItems.OrderID = Orders.OrderID
        ) LineItems2

Pamiętaj, że „ TOP 1bez” ORDER BYnie jest deterministyczne: w tym zapytaniu otrzymasz jeden element zamówienia na zamówienie, ale nie jest określone, który z nich będzie.

Wiele wywołań zapytania może dać różne elementy zamówienia dla tego samego zamówienia, nawet jeśli instrument bazowy nie zmienił się.

Jeśli chcesz uporządkować deterministycznie, dodaj ORDER BYklauzulę do najbardziej wewnętrznego zapytania.

Wiem, że odpowiedziano na to pytanie jakiś czas temu, ale w przypadku dużych zestawów danych zapytania zagnieżdżone mogą być kosztowne. Oto inne rozwiązanie, w którym zagnieżdżone zapytanie będzie uruchamiane 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

Mógłbyś:

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
  )

Wymaga to włączenia indeksu (lub klucza podstawowego) LineItems.LineItemIDi włączenia indeksu LineItems.OrderIDlub będzie on powolny.

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

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 wystarczy przetestować, które zapytanie daje lepszą wydajność.

, Kolejne podejście przy użyciu wspólnego wyrażenia tabelowego:

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 rzędy?

Wersja oddzielona przecinkami 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

Od SQL Server 2012 i później myślę, że to załatwi sprawę:

SELECT DISTINCT
    o.OrderNumber ,
    FIRST_VALUE(li.Quantity) OVER ( PARTITION BY o.OrderNumber ORDER BY li.Description ) AS Quantity ,
    FIRST_VALUE(li.Description) OVER ( PARTITION BY o.OrderNumber ORDER BY li.Description ) AS Description
FROM    Orders AS o
    INNER JOIN LineItems AS li ON o.OrderID = li.OrderID

Skorelowane podzapytania to podzapytania zależne od zapytania zewnętrznego. To jest jak pętla for w SQL. Zapytanie podrzędne będzie uruchamiane 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
)

EDYCJA: nieważne, Quassnoi ma lepszą odpowiedź.

W przypadku 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

Moim ulubionym sposobem uruchomienia tego zapytania jest klauzula nieistniejąca. Uważam, że jest to najbardziej skuteczny sposób na uruchomienie tego rodzaju zapytania:

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 przetestowałem tej metody w stosunku do innych sugerowanych tutaj metod.

Próbowałem krzyża, działa ładnie, ale trwa nieco dłużej. Skorygowano kolumny linii, aby mieć maksymalną i dodaną grupę, która utrzymywała prędkość i usunęła dodatkowy rekord.

Oto dostosowane zapytanie:

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

Spróbuj tego

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