SQL join: memilih catatan terakhir dalam hubungan satu ke banyak

Misalkan saya memiliki tabel pelanggan dan tabel pembelian. Setiap pembelian milik satu pelanggan. Saya ingin mendapatkan daftar semua pelanggan beserta pembelian terakhir mereka dalam satu pernyataan SELECT. Apa praktik terbaik? Adakah saran untuk membuat indeks?

Silakan gunakan nama tabel / kolom ini dalam jawaban Anda:

• pelanggan: id, nama
• pembelian: id, customer_id, item_id, tanggal

Dan dalam situasi yang lebih rumit, apakah akan (menguntungkan kinerja) bermanfaat untuk mendenormalkan basis data dengan menempatkan pembelian terakhir ke dalam tabel pelanggan?

Jika id (pembelian) dijamin disortir berdasarkan tanggal, dapatkah laporan disederhanakan dengan menggunakan sesuatu seperti LIMIT 1?

Ini adalah contoh dari greatest-n-per-groupmasalah yang telah muncul secara teratur di StackOverflow.

Inilah cara saya biasanya merekomendasikan untuk menyelesaikannya:

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;

Penjelasan: diberikan satu baris p1, seharusnya tidak ada baris p2dengan pelanggan yang sama dan tanggal kemudian (atau dalam kasus ikatan, nanti id). Ketika kami menemukan itu benar, maka p1adalah pembelian terbaru untuk pelanggan itu.

Mengenai indeks, saya akan membuat indeks senyawa dalam purchaseatas kolom ( customer_id, date, id). Itu memungkinkan sambungan luar dilakukan menggunakan indeks penutup. Pastikan untuk menguji pada platform Anda, karena optimasi bergantung pada implementasi. Gunakan fitur RDBMS Anda untuk menganalisis rencana pengoptimalan. Misalnya EXPLAINdi MySQL.

Beberapa orang menggunakan subquery alih-alih solusi yang saya tunjukkan di atas, tetapi saya menemukan solusi saya membuatnya lebih mudah untuk menyelesaikan ikatan.

Anda juga dapat mencoba melakukan ini menggunakan sub pilih

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

Pilih harus bergabung pada semua pelanggan dan tanggal pembelian terakhir mereka .

Anda belum menentukan basis datanya. Jika itu adalah salah satu yang memungkinkan fungsi analitis mungkin lebih cepat untuk menggunakan pendekatan ini daripada GROUP BY satu (pasti lebih cepat di Oracle, kemungkinan besar lebih cepat di edisi SQL Server akhir, tidak tahu tentang yang lain).

Sintaks dalam SQL Server adalah:

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

Pendekatan lain adalah dengan menggunakan NOT EXISTSkondisi dalam kondisi bergabung Anda untuk menguji pembelian selanjutnya:

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

Saya menemukan utas ini sebagai solusi untuk masalah saya.

Tetapi ketika saya mencobanya mereka kinerjanya rendah. Di bawah ini adalah saran saya untuk kinerja yang lebih baik.

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 

Semoga ini bisa membantu.

Jika Anda menggunakan PostgreSQL, Anda dapat menggunakan DISTINCT ONuntuk menemukan baris pertama dalam sebuah grup.

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 Documents - Distinct On

Perhatikan bahwa DISTINCT ONbidang - di sini customer_id- harus cocok dengan bidang paling kiri di ORDER BYklausa.

Peringatan: Ini adalah klausa yang tidak standar.

Coba ini, ini akan membantu.

Saya telah menggunakan ini dalam proyek saya.

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]

Diuji pada 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

Fungsi max()agregat akan memastikan bahwa pembelian terakhir dipilih dari masing-masing kelompok (tetapi mengasumsikan bahwa kolom tanggal dalam format di mana max () memberikan yang terbaru - yang biasanya merupakan kasus). Jika Anda ingin menangani pembelian dengan tanggal yang sama maka Anda dapat menggunakannya max(p.date, p.id).

Dalam hal indeks, saya akan menggunakan indeks pada pembelian dengan (customer_id, tanggal, [kolom pembelian lainnya yang ingin Anda kembalikan di pilih Anda]).

The LEFT OUTER JOIN(sebagai lawan INNER JOIN) akan memastikan bahwa pelanggan yang tidak pernah melakukan pembelian juga disertakan.

Silakan coba ini,

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;