Junção SQL: selecionando os últimos registros em um relacionamento um para muitos

Suponha que eu tenha uma tabela de clientes e uma tabela de compras. Cada compra pertence a um cliente. Desejo obter uma lista de todos os clientes, juntamente com sua última compra, em uma instrução SELECT. Qual é a melhor prática? Algum conselho sobre a criação de índices?

Use estes nomes de tabela / coluna na sua resposta:

• cliente: id, nome
• compra: id, customer_id, item_id, date

E em situações mais complicadas, seria benéfico (em termos de desempenho) desnormalizar o banco de dados colocando a última compra na tabela de clientes?

Se for garantido que o ID (compra) seja classificado por data, as instruções podem ser simplificadas usando algo como LIMIT 1?

Este é um exemplo do greatest-n-per-groupproblema que apareceu regularmente no StackOverflow.

Aqui está como eu geralmente recomendo resolvê-lo:

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;

Explicação: dada uma linha p1, não deve haver linha p2com o mesmo cliente e uma data posterior (ou, no caso de empates, posteriormente id). Quando achamos que isso é verdade, então p1é a compra mais recente para esse cliente.

Em relação índices, eu criar um índice composto em purchasesobre as colunas ( customer_id, date, id). Isso pode permitir que a junção externa seja feita usando um índice de cobertura. Teste sua plataforma, pois a otimização depende da implementação. Use os recursos do seu RDBMS para analisar o plano de otimização. Por exemplo, EXPLAINno MySQL.

Algumas pessoas usam subconsultas em vez da solução mostrada acima, mas acho que minha solução facilita a resolução de vínculos.

Você também pode tentar fazer isso usando um sub-select

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

A seleção deve ingressar em todos os clientes e na data da última compra.

Você não especificou o banco de dados. Se alguém permitir funções analíticas, pode ser mais rápido usar essa abordagem do que a abordagem GROUP BY (definitivamente mais rápida no Oracle, provavelmente mais rápida nas edições finais do SQL Server, não conheço outras).

A sintaxe no SQL Server seria:

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

Outra abordagem seria usar uma NOT EXISTScondição em sua condição de associação para testar compras posteriores:

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
   )
)

Encontrei este tópico como uma solução para o meu problema.

Mas quando os experimentei, o desempenho foi baixo. Abaixo está a minha sugestão para um melhor desempenho.

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 

Espero que isso seja útil.

Se você estiver usando o PostgreSQL, poderá DISTINCT ONencontrar a primeira linha de um grupo.

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 - Distinto em

Observe que os DISTINCT ONcampos - aqui customer_id- devem corresponder aos campos mais à esquerda no campoORDER BY cláusula.

Advertência: Esta é uma cláusula fora do padrão.

Tente isso, vai ajudar.

Eu usei isso no meu projeto.

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]

Testado em 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

A max()função agregada garantirá que a compra mais recente seja selecionada de cada grupo (mas assume que a coluna da data esteja em um formato no qual max () forneça a mais recente - o que normalmente é o caso). Se você quiser lidar com compras com a mesma data, poderá usarmax(p.date, p.id) .

Em termos de índices, eu usaria um índice na compra com (customer_id, date, [qualquer outra coluna de compra que você deseje retornar no seu select]).

O LEFT OUTER JOIN(ao contrário de INNER JOIN) garantirá que os clientes que nunca fizeram uma compra também sejam incluídos.

Por favor, tente isso,

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;