Unión SQL: selección de los últimos registros en una relación uno a muchos

Supongamos que tengo una tabla de clientes y una tabla de compras. Cada compra pertenece a un cliente. Quiero obtener una lista de todos los clientes junto con su última compra en una declaración SELECT. cual es la mejor practica? ¿Algún consejo sobre la creación de índices?

Utilice estos nombres de tabla / columna en su respuesta:

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

Y en situaciones más complicadas, ¿sería beneficioso (en términos de rendimiento) desnormalizar la base de datos colocando la última compra en la tabla de clientes?

Si se garantiza que la identificación (de compra) se ordenará por fecha, ¿se pueden simplificar las declaraciones usando algo como LIMIT 1?

Este es un ejemplo del greatest-n-per-groupproblema que ha aparecido regularmente en StackOverflow.

Así es como generalmente recomiendo resolverlo:

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;

Explicación: dada una fila p1, no debe haber una fila p2con el mismo cliente y una fecha posterior (o en el caso de empates, una posterior id). Cuando descubrimos que eso es cierto, entonces p1es la compra más reciente para ese cliente.

En cuanto a los índices, que crearía un índice compuesto en purchasemás de las columnas ( customer_id, date, id). Eso puede permitir que la unión externa se realice utilizando un índice de cobertura. Asegúrese de probar en su plataforma, porque la optimización depende de la implementación. Use las funciones de su RDBMS para analizar el plan de optimización. Por ejemplo, EXPLAINen MySQL.

Algunas personas usan subconsultas en lugar de la solución que muestro arriba, pero creo que mi solución hace que sea más fácil resolver los lazos.

También puedes intentar hacer esto usando una sub selección

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

El select debe unirse a todos los clientes y su última fecha de compra.

No ha especificado la base de datos. Si es uno que permite funciones analíticas, puede ser más rápido usar este enfoque que el GRUPO BY (definitivamente más rápido en Oracle, probablemente más rápido en las últimas ediciones de SQL Server, no conozco otros).

La sintaxis en SQL Server sería:

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

Otro enfoque sería usar una NOT EXISTScondición en su condición de unión para probar 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
   )
)

Encontré este hilo como una solución a mi problema.

Pero cuando los probé, el rendimiento fue bajo. A continuación es mi sugerencia para un mejor rendimiento.

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 

Esperamos que esto sea útil.

Si está utilizando PostgreSQL, puede utilizarlo DISTINCT ONpara encontrar la primera fila de un 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

Documentos de PostgreSQL: distintivo en

Tenga en cuenta que los DISTINCT ONcampos (aquí customer_id) deben coincidir con los campos más a la izquierda de la ORDER BYcláusula.

Advertencia: esta es una cláusula no estándar.

Intenta esto, te ayudará.

He usado esto en mi proyecto.

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]

Probado en 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()función de agregado asegurará que se seleccione la última compra de cada grupo (pero se supone que la columna de fecha está en un formato en el que max () proporciona la última, que normalmente es el caso). Si desea manejar compras con la misma fecha, puede usarlas max(p.date, p.id).

En términos de índices, usaría un índice en la compra con (customer_id, date, [cualquier otra columna de compra que desee devolver en su selección]).

El LEFT OUTER JOIN(a diferencia de INNER JOIN) se asegurará de que los clientes que nunca hayan realizado una compra también estén incluidos.

Por favor intente esto,

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;