SQL-соединение: выбор последних записей в отношении «один ко многим»

Предположим, у меня есть таблица клиентов и таблица покупок. Каждая покупка принадлежит одному клиенту. Я хочу получить список всех клиентов вместе с их последней покупкой в ​​одном операторе SELECT. Какова лучшая практика? Любой совет по созданию индексов?

Пожалуйста, используйте эти имена таблиц / столбцов в своем ответе:

• Заказчик: идентификатор, имя
• покупка: id, customer_id, item_id, дата

И в более сложных ситуациях было бы (с точки зрения производительности) выгодно денормализовать базу данных, поместив последнюю покупку в таблицу клиентов?

Если идентификатор (покупки) гарантированно отсортирован по дате, можно ли упростить выписки, используя что-то вроде LIMIT 1?

Это пример greatest-n-per-groupпроблемы, которая регулярно появлялась в StackOverflow.

Вот как я обычно рекомендую решить эту проблему:

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;

Объяснение: для данной строки p1не должно быть строки p2с тем же клиентом и более поздней датой (или, в случае связей, более поздней id). Когда мы обнаруживаем, что это правда, p1это самая последняя покупка для этого клиента.

Что касается индексов, я бы создать составной индекс в purchaseтечение столбцов ( customer_id, date, id). Это может позволить внешнему соединению быть выполненным, используя индекс покрытия. Обязательно протестируйте на своей платформе, потому что оптимизация зависит от реализации. Используйте функции вашей РСУБД для анализа плана оптимизации. Например, EXPLAINна MySQL.

Некоторые люди используют подзапросы вместо решения, которое я показываю выше, но я считаю, что мое решение облегчает разрешение связей.

Вы также можете попробовать сделать это с помощью суб-выбора

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

Выбор должен присоединиться ко всем клиентам и их дате последней покупки.

Вы не указали базу данных. Если это та функция, которая допускает аналитические функции, возможно, этот подход будет быстрее, чем метод GROUP BY (определенно быстрее в Oracle, скорее всего быстрее в поздних выпусках SQL Server, о других не знаю).

Синтаксис в SQL Server будет:

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

Другой подход заключается в использовании NOT EXISTSусловия в вашем условии соединения для проверки последующих покупок:

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

Я нашел эту тему как решение моей проблемы.

Но когда я попробовал их, производительность была низкой. Сильфон мое предложение для лучшей производительности.

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 

Надеюсь, это будет полезно.

Если вы используете PostgreSQL, вы можете DISTINCT ONнайти первую строку в группе.

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 - четко определенные

Обратите внимание, что DISTINCT ONполе (поля) - здесь customer_id- должно соответствовать крайнему левому полю (ам) в ORDER BYпредложении.

Предостережение: это нестандартное предложение.

Попробуйте это, это поможет.

Я использовал это в своем проекте.

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]

Протестировано на 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

Функция max()агрегирования будет следить за тем, чтобы в каждой группе была выбрана самая последняя покупка (но предполагается, что столбец даты имеет формат, в котором max () выдает самую последнюю - что обычно имеет место). Если вы хотите обрабатывать покупки с той же датой, вы можете использовать max(p.date, p.id).

Что касается индексов, я бы использовал индекс покупок с (customer_id, date, [любые другие столбцы покупок, которые вы хотите вернуть в вашем выборе]).

LEFT OUTER JOIN(В отличие от INNER JOIN) будет убедиться , что клиенты , которые никогда не делали покупки, также включены.

Пожалуйста, попробуйте это,

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;