Join SQL: selezione degli ultimi record in una relazione uno-a-molti

Supponiamo che io abbia una tabella di clienti e una tabella di acquisti. Ogni acquisto appartiene a un cliente. Voglio ottenere un elenco di tutti i clienti insieme al loro ultimo acquisto in un'istruzione SELECT. Qual è la migliore pratica? Qualche consiglio sulla costruzione di indici?

Usa questi nomi di tabella / colonna nella tua risposta:

• cliente: id, nome
• acquisto: id, customer_id, item_id, data

E in situazioni più complicate, sarebbe (dal punto di vista delle prestazioni) vantaggioso denormalizzare il database inserendo l'ultimo acquisto nella tabella dei clienti?

Se si garantisce che l'ID (acquisto) sia ordinato per data, le dichiarazioni possono essere semplificate usando qualcosa di simile LIMIT 1?

Questo è un esempio del greatest-n-per-groupproblema che è apparso regolarmente su StackOverflow.

Ecco come di solito consiglio di risolverlo:

SELECT c.*, p1.*
FROM customer c
JOIN purchase p1 ON (c.id = p1.customer_id)
LEFT OUTER JOIN purchase p2 ON (c.id = p2.customer_id AND 
    (p1.date < p2.date OR (p1.date = p2.date AND p1.id < p2.id)))
WHERE p2.id IS NULL;

Spiegazione: data una riga p1, non ci dovrebbero essere righe p2con lo stesso cliente e una data successiva (o, nel caso di legami, una versione successiva id). Quando scopriamo che ciò è vero, allora p1è l'acquisto più recente per quel cliente.

Per quanto riguarda gli indici, mi piacerebbe creare un indice composto in purchasesopra le colonne ( customer_id, date, id). Ciò può consentire il collegamento esterno mediante un indice di copertura. Assicurati di testare sulla tua piattaforma, poiché l'ottimizzazione dipende dall'implementazione. Utilizza le funzionalità del tuo RDBMS per analizzare il piano di ottimizzazione. Ad esempio EXPLAINsu MySQL.

Alcune persone usano le subquery invece della soluzione mostrata sopra, ma trovo che la mia soluzione semplifichi la risoluzione dei legami.

Puoi anche provare a farlo usando una sottoselezione

SELECT  c.*, p.*
FROM    customer c INNER JOIN
        (
            SELECT  customer_id,
                    MAX(date) MaxDate
            FROM    purchase
            GROUP BY customer_id
        ) MaxDates ON c.id = MaxDates.customer_id INNER JOIN
        purchase p ON   MaxDates.customer_id = p.customer_id
                    AND MaxDates.MaxDate = p.date

La selezione dovrebbe aderire a tutti i clienti e alla data dell'ultimo acquisto.

Non hai specificato il database. Se è uno che consente le funzioni analitiche, potrebbe essere più veloce utilizzare questo approccio rispetto a GROUP BY uno (sicuramente più veloce in Oracle, molto probabilmente più veloce nelle ultime edizioni di SQL Server, non conoscerne altri).

La sintassi in SQL Server sarebbe:

SELECT c.*, p.*
FROM customer c INNER JOIN 
     (SELECT RANK() OVER (PARTITION BY customer_id ORDER BY date DESC) r, *
             FROM purchase) p
ON (c.id = p.customer_id)
WHERE p.r = 1

Un altro approccio sarebbe quello di utilizzare una NOT EXISTScondizione nella condizione di partecipazione per testare acquisti successivi:

SELECT *
FROM customer c
LEFT JOIN purchase p ON (
       c.id = p.customer_id
   AND NOT EXISTS (
     SELECT 1 FROM purchase p1
     WHERE p1.customer_id = c.id
     AND p1.id > p.id
   )
)

Ho trovato questa discussione come soluzione al mio problema.

Ma quando li ho provati le prestazioni erano basse. Muggito è il mio suggerimento per prestazioni migliori.

With MaxDates as (
SELECT  customer_id,
                MAX(date) MaxDate
        FROM    purchase
        GROUP BY customer_id
)

SELECT  c.*, M.*
FROM    customer c INNER JOIN
        MaxDates as M ON c.id = M.customer_id 

Spero che questo possa essere utile.

Se stai usando PostgreSQL puoi usare DISTINCT ONper trovare la prima riga in un gruppo.

SELECT customer.*, purchase.*
FROM customer
JOIN (
   SELECT DISTINCT ON (customer_id) *
   FROM purchase
   ORDER BY customer_id, date DESC
) purchase ON purchase.customer_id = customer.id

PostgreSQL Docs - Distinct On

Si noti che i DISTINCT ONcampi - qui customer_id- devono corrispondere ai campi più a sinistra nella ORDER BYclausola.

Avvertenza: questa è una clausola non standard.

Prova questo, aiuterà.

L'ho usato nel mio progetto.

SELECT 
*
FROM
customer c
OUTER APPLY(SELECT top 1 * FROM purchase pi 
WHERE pi.customer_id = c.Id order by pi.Id desc) AS [LastPurchasePrice]

Testato su SQLite:

SELECT c.*, p.*, max(p.date)
FROM customer c
LEFT OUTER JOIN purchase p
ON c.id = p.customer_id
GROUP BY c.id

La max()funzione di aggregazione assicurerà che l'ultimo acquisto sia selezionato da ciascun gruppo (ma presuppone che la colonna della data sia in un formato in cui max () fornisce l'ultimo - che è normalmente il caso). Se si desidera gestire gli acquisti con la stessa data, è possibile utilizzare max(p.date, p.id).

In termini di indici, utilizzerei un indice per l'acquisto con (customer_id, data, [qualsiasi altra colonna di acquisto che desideri restituire nella tua selezione]).

Il LEFT OUTER JOIN(al contrario di INNER JOIN) farà in modo che siano inclusi anche i clienti che non hanno mai effettuato un acquisto.

Per favore prova questo,

SELECT 
c.Id,
c.name,
(SELECT pi.price FROM purchase pi WHERE pi.Id = MAX(p.Id)) AS [LastPurchasePrice]
FROM customer c INNER JOIN purchase p 
ON c.Id = p.customerId 
GROUP BY c.Id,c.name;