Perlu diperhatikan bahwa Anda sedang melihat dokumentasi Looker. Untuk melihat dokumentasi Looker Studio, buka https://support.google.com/looker-studio.

Bekerja dengan gabungan di LookML

Gabungan memungkinkan Anda menghubungkan tampilan yang berbeda sehingga Anda dapat menjelajahi data dari beberapa tampilan sekaligus dan melihat bagaimana bagian yang berbeda dari data Anda saling terkait.

Misalnya, database Anda mungkin menyertakan tabel order_items, orders, dan users. Anda dapat menggunakan {i>join<i} untuk menjelajahi data dari semua tabel secara bersamaan. Halaman ini menjelaskan gabungan di LookML, termasuk parameter gabungan dan pola penggabungan tertentu.

Bergabung dengan Explore dimulai dengan Explore

Gabungan ditentukan dalam file model untuk menetapkan hubungan antara Jelajah dan tampilan. Gabungan menghubungkan satu atau beberapa tampilan ke satu Jelajah, baik secara langsung maupun melalui tampilan gabungan lainnya.

Mari kita pertimbangkan dua tabel database: order_items dan orders. Setelah membuat tampilan untuk kedua tabel, deklarasikan satu atau beberapa tabel di bagian parameter explore di file model:

explore: order_items { ... }

Saat Anda menjalankan kueri dari Jelajah order_items, order_items akan muncul dalam klausa FROM dari SQL yang dihasilkan:

SELECT ...
FROM order_items

Anda dapat bergabung dengan informasi tambahan ke Jelajah order_items. Misalnya, Anda dapat menggunakan contoh LookML berikut untuk menggabungkan tampilan orders ke Jelajah order_items:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
  }
}

LookML di atas menyelesaikan dua hal. Pertama, Anda dapat melihat kolom dari orders dan order_items di UI:

Eksplorasi Item Pesanan mencakup kolom dari tampilan Item Pesanan dan kolom dari tampilan Pesanan gabungan.

Kedua, LookML menjelaskan cara menggabungkan orders dan order_items. LookML itu akan diterjemahkan ke SQL berikut:

SELECT ...
FROM order_items
LEFT JOIN orders
ON order_items.order_id = orders.id

Parameter LookML ini dijelaskan secara lebih mendetail di bagian berikut. Lihat halaman referensi parameter join untuk mempelajari lebih lanjut bagaimana LookML ini diterjemahkan ke dalam SQL.

Tips Tim Chat: Pengguna bertanya lebih banyak tentang error validasi, "Kolom tidak diketahui atau tidak dapat diakses", yang dapat disebabkan oleh tidak adanya penggabungan. Lihat halaman Praktik Terbaik tentang error ini untuk informasi selengkapnya.

Parameter join

Empat parameter utama digunakan untuk menggabungkan: join, type, relationship, dan sql_on.

Langkah 1: Memulai Jelajah

Pertama, buat Jelajah order_items:

explore: order_items { ... }

Langkah 2: `join`

Untuk bergabung ke tabel, Anda harus mendeklarasikannya terlebih dahulu dalam tampilan. Dalam contoh ini, orders adalah tampilan yang sudah ada di model Anda.

Kemudian, gunakan parameter join untuk mendeklarasikan bahwa Anda ingin menggabungkan tampilan orders ke order_items:

explore: order_items {
  join: orders { ... }
}

Langkah 3: `type`

Pertimbangkan type gabungan yang akan dijalankan. Looker mendukung LEFT JOIN, INNER JOIN, FULL OUTER JOIN, dan CROSS JOIN. Keduanya sesuai dengan nilai parameter type dari left_outer, inner, full_outer, dan cross.

explore: order_items {
  join: orders {
    type: left_outer
  }
}

Nilai default type adalah left_outer, dan umumnya merupakan jenis gabungan yang populer.

Langkah 4: `relationship`

Tentukan gabungan relationship antara order_items dan orders. Mendeklarasikan relationship gabungan dengan benar sangat penting bagi Looker untuk menghitung ukuran yang akurat. Hubungan ditentukan dari Jelajah order_items hingga tampilan orders. Opsi yang mungkin adalah one_to_one, many_to_one, one_to_many, dan many_to_many.

Dalam contoh ini, bisa ada banyak order_items untuk satu order. Hubungan dari order_items dengan orders adalah many_to_one:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
  }
}

Jika Anda tidak menyertakan relationship dalam gabungan, Looker akan ditetapkan secara default ke many_to_one.

Untuk tips tambahan tentang cara menentukan parameter relationship dengan benar untuk gabungan, lihat halaman Menyiapkan parameter relationship dengan benar.

Langkah 5: `sql_on`

Deklarasikan cara menggabungkan kedua tabel ini dengan parameter sql_on atau foreign_key. Kami biasanya menyarankan sql_on karena dapat melakukan apa saja yang dapat dilakukan foreign_key, tetapi biasanya lebih mudah dipahami.

sql_on setara dengan klausa ON dalam SQL yang dihasilkan untuk suatu kueri. Dengan parameter ini, kita dapat mendeklarasikan kolom mana yang harus dicocokkan untuk melakukan penggabungan:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
  }
}

Anda juga dapat menulis {i>join<i} yang lebih kompleks. Misalnya, Anda mungkin hanya ingin bergabung ke pesanan dengan id yang lebih besar dari 1.000:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} AND ${orders.id} > 1000 ;;
  }
}

Lihat operator substitusi untuk mempelajari lebih lanjut sintaksis ${ ... } dalam contoh berikut.

Langkah 6: Pengujian

Uji apakah gabungan ini berfungsi seperti yang diharapkan dengan membuka Eksplorasi Order Items. Anda akan melihat kolom dari order_items dan orders.

Lihat Pengembangan Model untuk mempelajari lebih lanjut cara menguji perubahan LookML.

Bergabung melalui tampilan lain

Anda dapat menggabungkan tampilan ke Jelajah melalui tampilan lain. Pada contoh di atas, Anda menggabungkan orders ke order_items melalui kolom order_id. Kita mungkin juga ingin menggabungkan data dari tampilan yang disebut users ke Jelajah order_items, meskipun tampilan tersebut tidak menggunakan kolom yang sama. Hal ini dapat dilakukan dengan bergabung melalui tampilan orders.

Gunakan sql_on atau foreign_key untuk bergabung dengan users ke orders, bukan order_items. Lakukan hal ini dengan mencakup kolom dengan benar dari orders sebagai orders.user_id.

Berikut adalah contoh penggunaan sql_on:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
  }
  join: users {
    type: left_outer
    relationship: many_to_one
    sql_on: ${orders.user_id} = ${users.id} ;;
  }
}

Bergabung ke tampilan lebih dari sekali

Tampilan users berisi data untuk pembeli dan penjual. Untuk menggabungkan data dari tampilan ini ke order_items, tetapi melakukannya secara terpisah untuk pembeli dan penjual, Anda dapat menggabungkan users dua kali, dengan nama yang berbeda, menggunakan parameter from.

Parameter from memungkinkan Anda menentukan tampilan yang akan digunakan dalam gabungan, sekaligus memberikan nama unik untuk gabungan tersebut. Contoh:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
  }
  join: buyers {
    from: users
    type: left_outer
    relationship: many_to_one
    sql_on: ${orders.buyer_id} = ${buyers.id} ;;
  }
  join: sellers {
    from: users
    type: left_outer
    relationship: many_to_one
    sql_on: ${orders.seller_id} = ${sellers.id} ;;
  }
}

Dalam hal ini, hanya data pembeli yang digabungkan sebagai buyers, sedangkan hanya data penjual yang digabungkan sebagai sellers.

Catatan: Tampilan users sekarang harus dirujuk oleh nama alias buyers dan sellers di gabungan.

Membatasi kolom dari gabungan

Parameter fields memungkinkan Anda menentukan kolom mana yang dibawa dari gabungan ke Jelajah. Secara default, semua kolom dari tampilan dibawa saat digabungkan. Namun, Anda mungkin hanya ingin menggunakan subkumpulan kolom.

Misalnya, saat orders digabungkan ke order_items, Anda mungkin hanya ingin memindahkan kolom shipping dan tax melalui gabungan:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
    fields: [shipping, tax]
  }
}

Anda juga dapat mereferensikan sekumpulan kolom, seperti [set_a*]. Setiap kumpulan ditentukan dalam tampilan menggunakan parameter set. Misalkan Anda memiliki kumpulan berikut yang ditentukan dalam tampilan orders:

set: orders_set {
  fields: [created_date, shipping, tax]
}

Anda dapat memilih untuk hanya memindahkan tiga kolom ini saat bergabung dengan orders ke order_items:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
    fields: [orders_set*]
  }
}

Agregat simetris

Looker menggunakan fitur yang disebut "agregat simetris" untuk menghitung agregasi (seperti jumlah dan rata-rata) dengan benar, bahkan saat penggabungan menghasilkan fanout. Agregat simetris dijelaskan secara lebih mendetail di halaman Praktik Terbaik Memahami agregat simetris, dan masalah fanout yang diatasi dijelaskan dalam Postingan komunitas Masalah fanout SQL.

Kunci utama wajib diisi

Agar ukuran (agregasi) dihasilkan melalui gabungan, Anda harus menentukan kunci utama di semua tampilan yang terlibat dalam penggabungan.

Lakukan hal ini dengan menambahkan parameter primary_key ke definisi kolom kunci utama di setiap tampilan:

dimension: id {
  type: number
  primary_key: yes
}

Untuk menangani tindakan gabungan dengan benar, Looker mengandalkan kunci utama dengan nilai yang benar-benar unik dan memiliki nilai non-NULL. Jika data Anda tidak berisi kunci utama, pertimbangkan apakah penggabungan beberapa kolom akan menghasilkan kunci utama dengan nilai non-NULL yang benar-benar unik. Jika kunci utama Anda tidak unik atau berisi nilai NULL dan kueri Anda menyertakan data yang mengungkapkan masalah tersebut, Looker akan menampilkan error seperti yang dijelaskan pada halaman Error: Non-Unique value/primary key (atau sql_distinct_key), value overflow, atau collision when computing sum.

Dialek SQL yang didukung

Agar Looker dapat mendukung penggabungan simetris dalam project Looker, dialek database Anda juga harus mendukungnya. Tabel berikut menunjukkan dialek mana yang mendukung agregat simetris dalam rilis Looker terbaru:

Dialek	Didukung?
Actian Avalanche	Ya
Amazon Athena	Ya
Amazon Aurora MySQL	Ya
Amazon Redshift	Ya
Apache Druid	Tidak
Apache Druid 0.13+	Tidak
Apache Druid 0.18+	Tidak
Apache Hive 2.3 dan yang lebih baru	Tidak
Apache Hive 3.1.2+	Tidak
Apache Spark 3+	Ya
ClickHouse	Tidak
Cloudera Impala 3.1+	Ya
Cloudera Impala 3.1+ dengan Native Driver	Ya
Cloudera Impala dengan Native Driver	Tidak
DataVirtuality	Ya
Databricks	Ya
Denodo 7	Ya
Denodo 8	Ya
Dremio	Tidak
Dremio 11+	Ya
Exasol	Ya
Firebolt	Ya
Legacy SQL Google BigQuery	Ya
SQL Standar Google BigQuery	Ya
PostgreSQL Google Cloud	Ya
Google Cloud SQL	Ya
Google Spanner	Ya
Greenplum	Ya
HyperSQL	Tidak
IBM Netezza	Ya
MariaDB	Ya
Microsoft Azure PostgreSQL	Ya
Microsoft Azure SQL Database	Ya
Microsoft Azure Synapse Analytics	Ya
Microsoft SQL Server 2008+	Ya
Microsoft SQL Server 2012+	Ya
Microsoft SQL Server 2016	Ya
Microsoft SQL Server 2017+	Ya
MongoBI	Tidak
MySQL	Ya
MySQL 8.0.12+	Ya
Oracle	Ya
Oracle ADWC	Ya
PostgreSQL 9.5+	Ya
PostgreSQL versi 9.5	Ya
PrestoDB	Ya
PrestoSQL	Ya
SAP HANA	Ya
SAP HANA 2+	Ya
SingleStore	Ya
SingleStore 7+	Ya
Snowflake	Ya
Teradata	Ya
Trino	Ya
Vector	Ya
Vertica	Ya

Jika dialek Anda tidak mendukung agregat simetris, berhati-hatilah saat mengeksekusi gabungan di Looker, karena beberapa jenis gabungan dapat menghasilkan agregasi yang tidak akurat (seperti jumlah dan rata-rata). Masalah ini dan solusi untuknya dijelaskan dengan sangat mendetail di Postingan komunitas Masalah fanout SQL.

Pelajari lebih lanjut

Untuk mempelajari lebih lanjut parameter gabungan di LookML, lihat dokumentasi Referensi gabungan.