Come partecipare alla prima riga

Userò un esempio concreto, ma ipotetico.

Ogni ordine ha normalmente un solo elemento pubblicitario :

Ordini:

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

Ma a volte ci sarà un ordine con due elementi pubblicitari:

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

Normalmente quando si mostrano gli ordini all'utente:

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

Voglio mostrare il singolo articolo sull'ordine. Ma con questo ordine occasionale contenente due (o più) elementi, gli ordini sarebbero appaiono essere duplicato :

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

Quello che voglio davvero è avere SQL Server solo sceglierne uno , poiché sarà abbastanza buono :

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

Se divento avventuroso, potrei mostrare all'utente un'ellissi per indicare che ce n'è più di uno:

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

Quindi la domanda è come

• eliminare le righe "duplicate"
• solo unirsi a una delle righe, per evitare la duplicazione

Primo tentativo

Il mio primo ingenuo tentativo è stato quello di unirmi solo agli elementi pubblicitari " 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

Ma questo dà l'errore:

La colonna o il prefisso "Ordini" non
corrispondono a un nome di tabella o alias
utilizzato nella query.

Presumibilmente perché la selezione interna non vede la tabella esterna.

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

In SQL Server 2005 e versioni successive, è possibile sostituire INNER JOINcon 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

Tieni presente che TOP 1senza ORDER BYnon è deterministico: questa query ti fornirà un elemento pubblicitario per ordine, ma non è definito quale sarà.

Più invocazioni della query possono fornire elementi pubblicitari diversi per lo stesso ordine, anche se il sottostante non è cambiato.

Se si desidera un ordine deterministico, è necessario aggiungere una ORDER BYclausola alla query più interna.

So che a questa domanda è stata data risposta qualche tempo fa, ma quando si ha a che fare con set di dati di grandi dimensioni, le query nidificate possono essere costose. Ecco una soluzione diversa in cui la query nidificata verrà eseguita una sola volta, anziché per ogni riga restituita.

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

Potresti fare:

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
  )

Ciò richiede un indice (o chiave primaria) attivo LineItems.LineItemIDe un indice attivo LineItems.OrderIDo sarà lento.

La risposta di @Quassnoi è buona, in alcuni casi (specialmente se la tabella esterna è grande), una query più efficiente potrebbe essere con l'utilizzo di funzioni con finestre, come questa:

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

A volte è sufficiente verificare quale query offre prestazioni migliori.

, Un altro approccio che utilizza l'espressione di tabella comune:

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

o, alla fine, vorresti mostrare tutte le righe unite?

versione separata da virgola qui:

  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

Da SQL Server 2012 in poi penso che questo farà il trucco:

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

Le query secondarie correlate sono query secondarie che dipendono dalla query esterna. È come un ciclo for in SQL. La query secondaria verrà eseguita una volta per ogni riga nella query esterna:

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
)

EDIT: non importa, Quassnoi ha una risposta migliore.

Per SQL2K, qualcosa del genere:

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

Il mio modo preferito per eseguire questa query è con una clausola inesistente. Credo che questo sia il modo più efficiente per eseguire questo tipo di query:

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
    )

Ma non ho testato questo metodo con altri metodi suggeriti qui.

Ho provato la croce, funziona bene, ma impiega un po 'più di tempo. Colonne di linea regolate per avere il gruppo massimo e aggiunto che ha mantenuto la velocità e lasciato cadere il record extra.

Ecco la query modificata:

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

prova questo

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