Merge dan join data frame di R (merge, left_join)

Dua tabel, satu kunci

Data nyata jarang berada di satu tabel. Pelanggan ada di satu data frame, pesanan mereka di data frame lain, dan pertanyaannya ("berapa total belanja setiap pelanggan?") butuh keduanya. Yang menghubungkan keduanya adalah kunci: kolom yang ada di setiap tabel dan mengidentifikasi entitas yang sama. Menggabungkan tabel berdasarkan kunci disebut join (istilah SQL) atau merge (istilah base R); operasinya sama.

Berikut pasangan tabel yang dipakai di sisa halaman ini. Perhatikan bahwa pelanggan 5 membuat pesanan tapi tidak ada di tabel pelanggan, sedangkan pelanggan 2 dan 4 tidak pernah memesan:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(customers)
print(orders)

Ketidakcocokan itu disengaja: apa yang dilakukan join terhadap baris yang tidak punya pasangan itulah yang membedakan jenis-jenis join.

merge(): inner join secara default

merge(x, y, by = "key") mencocokkan baris dengan kunci yang sama dan menyambung kolom-kolomnya. Secara default fungsi ini hanya mempertahankan kunci yang ada di kedua tabel, yaitu inner join:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(merge(customers, orders, by = "id"))

Tiga baris yang kembali. Ana muncul dua kali: ia punya dua pesanan, dan join menghasilkan satu baris output untuk setiap pasangan yang cocok. Ben dan Dana hilang (tidak punya pesanan), begitu pula pesanan misterius dari pelanggan 5 (tidak punya pelanggan). Inner join diam-diam membuang baris yang tidak punya pasangan dari kedua tabel: tepat saat kamu hanya peduli pada pasangan yang lengkap, dan menjadi bug kehilangan data yang diam saat kamu tidak menginginkannya.

Left, right, dan full join: all.x, all.y, all

Untuk mempertahankan baris yang tidak punya pasangan, tentukan baris tabel mana yang tidak boleh hilang. all.x = TRUE mempertahankan setiap baris tabel pertama, yaitu left join, jenis join yang paling sering dipakai dalam praktik:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(merge(customers, orders, by = "id", all.x = TRUE))

Sekarang Ben dan Dana bertahan, dengan NA di amount, yang berarti "pelanggan ini ada; tidak ada pesanan yang cocok." NA itu informatif, bukan sampah: is.na(result$amount) persis daftar pelanggan yang tidak pernah memesan (dokumentasi nilai yang hilang membahas cara bekerja dengannya). Varian lainnya adalah gagasan yang sama ke arah lain: all.y = TRUE mempertahankan setiap baris tabel kedua (right join; pesanan dari pelanggan 5 yang tidak dikenal akan bertahan dengan NA di name), dan all = TRUE mempertahankan semuanya dari kedua sisi (full join).

Pilih dengan bertanya: baris milik siapa yang tidak boleh kuhilangkan? Memperkaya tabel utama dengan data rujukan: left join, tabel utama di depan. Mengaudit kedua arah: full join.

Nama kunci yang berbeda: by.x dan by.y

Tabel jarang sepakat soal penamaan: id di satu tabel, customer_id di tabel lain. Jangan mengganti nama; beri tahu merge() kedua namanya:

customers <- data.frame(
    id   = c(1, 2, 3),
    name = c("Ana", "Ben", "Chen")
)
orders <- data.frame(
    customer_id = c(1, 3, 3),
    amount      = c(250, 120, 60)
)

print(merge(customers, orders, by.x = "id", by.y = "customer_id"))

Output-nya memakai nama dari tabel pertama untuk kuncinya. Masih terkait: kalau kedua tabel punya nama kolom bukan kunci yang sama (misalnya keduanya punya date), merge memberinya akhiran date.x dan date.y. Segera ganti namanya, karena sangat tidak enak dibaca.

Join di dplyr

dplyr memberi setiap jenis join verb-nya sendiri, sehingga maksudnya ada di nama fungsi, bukan di argumen penanda (statis; sandbox ini hanya menjalankan base R):

library(dplyr)

left_join(customers, orders, by = "id")
inner_join(customers, orders, by = "id")
full_join(customers, orders, by = "id")
left_join(customers, orders, by = c("id" = "customer_id"))  # different names

Selain lebih mudah dibaca, left_join() mempertahankan urutan baris tabel pertama (merge() mengurutkan ulang berdasarkan kunci) dan memberi peringatan keras tentang kecocokan many-to-many; lihat pengantar dplyr untuk keluarga verb-nya.

Anggota yang kurang dihargai adalah anti_join(): fungsi ini mengembalikan baris tabel pertama yang tidak punya pasangan di tabel kedua, tanpa menambah kolom, hanya sisa-sisanya:

anti_join(customers, orders, by = "id")   # customers who never ordered

Pertanyaan itu ("baris mana yang gagal dicocokkan?") terus-menerus muncul saat membersihkan data (ID yang tidak cocok, catatan yatim, pencarian yang gagal), dan anti_join() menjawabnya dalam satu pemanggilan, sementara base R butuh customers[!(customers$id %in% orders$id), ].

Menumpuk baris: rbind()

Join menggabungkan kolom dua tabel. Saat yang kamu punya justru dua kelompok baris dari jenis yang sama (pesanan Januari dan Februari), tumpuk keduanya dengan rbind():

jan <- data.frame(id = c(1, 2), amount = c(250, 40))
feb <- data.frame(id = c(3, 4), amount = c(120, 60))

print(rbind(jan, feb))

Syaratnya ketat: kedua data frame harus punya nama kolom yang sama (urutannya bebas, karena rbind mencocokkan berdasarkan nama). Kolom yang hilang atau berlebih menimbulkan error, bukan diisi dengan NA. Saat kolom-kolom antarkelompok sudah bergeser, bind_rows() dari dplyr lebih pemaaf: fungsi itu menyejajarkan berdasarkan nama dan mengisi celahnya dengan NA.

Ledakan kunci ganda

Kecelakaan join klasik: kunci yang kamu kira unik, ternyata tidak, di kedua tabel. Setiap kecocokan berpasangan dengan setiap kecocokan lainnya, sehingga jumlah barisnya berlipat:

a <- data.frame(id = c(1, 1), x = c("a1", "a2"))
b <- data.frame(id = c(1, 1), y = c("b1", "b2"))

merged <- merge(a, b, by = "id")
print(merged)
cat("rows:", nrow(merged), "\n")

Dua baris yang di-join dengan dua baris menghasilkan empat: setiap x dipasangkan dengan setiap y. Pada data nyata, beginilah tabel 10.000 baris menjadi 3 juta baris dan total pendapatan menjadi dua kali lipat. merge() melakukannya diam-diam. Pertahanannya adalah kebiasaan: sebelum join, periksa kunci yang kamu anggap unik (anyDuplicated(customers$id) seharusnya 0), dan setelah join, periksa kewajaran nrow() dibandingkan dengan yang kamu harapkan.

Yang kamu bawa pulang

• merge(x, y, by = "key") adalah inner join: baris yang tidak punya pasangan hilang diam-diam.
• all.x = TRUE (left), all.y = TRUE (right), all = TRUE (full) mempertahankan baris yang tidak punya pasangan dan mengisinya dengan NA.
• Nama kunci yang berbeda: by.x / by.y di base R, by = c("a" = "b") di dplyr.
• dplyr memberi nama pada setiap join; anti_join(), yaitu baris yang tidak punya pasangan, adalah yang kurang dihargai.
• rbind() menumpuk tabel yang bentuknya sama; kolomnya harus cocok berdasarkan nama.
• Kunci ganda melipatgandakan baris diam-diam; periksa anyDuplicated() sebelumnya dan nrow() sesudahnya.

Berikutnya: mengubah bentuk data antara format lebar dan panjang dengan pivot_longer() dan pivot_wider().