Ringkasan
Dengan penyempurnaan LookML, Anda dapat menyesuaikan tampilan atau Explore yang ada tanpa mengedit file LookML yang memuatnya. Ini ideal untuk:
- Project dengan Blok Looker, yang menggunakan LookML yang telah dibuat sebelumnya
- Project yang mengimpor file dari project lain
- Project yang sering Anda gunakan untuk membuat file dari tabel di database
- Situasi ketika Anda ingin membagikan LookML antarmodel atau project sambil melakukan penyesuaian di setiap tempat (konfigurasi hub-and-spoke)
Misalnya, jika Anda memiliki file tampilan berikut dalam project:
view: flights {
sql_table_name: flightstats.accidents ;;
dimension: id {
label: "id"
primary_key: yes
type: number
sql: ${TABLE}.id ;;
}
}
Anda dapat menyaring tampilan flights
seperti yang ditunjukkan di bawah: Gunakan parameter view
dengan nama tampilan yang sama, tetapi tambahkan tanda plus (+
) di depan nama untuk menunjukkan bahwa ini merupakan penyempurnaan dari tampilan yang sudah ada.
Penajaman ini menambahkan dimensi air_carrier
ke tampilan flights
yang ada:
view: +flights {
dimension: air_carrier {
type: string
sql: ${TABLE}.air_carrier ;;
}
}
Peningkatan ini dapat dilakukan pada file LookML apa pun dalam project, seperti file model, file tampilan, atau file LookML khusus sendiri. Lihat bagian Menggunakan penajaman di project LookML Anda untuk cara kerjanya.
Peningkatan yang dikombinasikan dengan LookML asli memiliki hasil akhir seolah-olah ini adalah LookML asli untuk tampilan:
view: flights {
sql_table_name: flightstats.accidents ;;
dimension: id {
label: "id"
primary_key: yes
type: number
sql: ${TABLE}.id ;;
}
dimension: air_carrier {
type: string
sql: ${TABLE}.air_carrier ;;
}
}
Di UI Looker, pengguna akan melihat dimensi Air Carrier, seolah-olah Anda telah menambahkan dimensi ke file tampilan asli itu sendiri.
Lihat contoh di bawah untuk informasi penerapan yang lebih mendetail.
Penajaman dibandingkan dengan perluasan
Looker juga mendukung extending objek LookML. Perluasan berguna saat Anda ingin membuat salinan baru dari tampilan yang sudah ada atau Explore sehingga Anda dapat menambahkan objek baru ke dalamnya. Misalnya, Anda dapat membuat tampilan dasar yang mendefinisikan semua kolom Anda, lalu membuat beberapa tampilan baru yang memperluas tampilan dasar. Tampilan baru ini kemudian dapat dimodifikasi untuk menyembunyikan kolom tertentu dalam tampilan dasar, atau untuk mengubah definisi atau label kolom dari tampilan dasar.
Penajaman berguna saat Anda ingin memodifikasi tampilan yang ada atau Explore dengan sedikit penyesuaian atau penyesuaian pada objek tertentu, tetapi Anda tidak ingin membuat salinan tampilan atau Explore. Penajaman ideal untuk situasi saat Anda tidak dapat atau tidak ingin mengubah tampilan dasar atau Explore, dan untuk situasi saat pembuatan tampilan baru atau Explore akan memerlukan perubahan ekstensif pada referensi LookML lainnya. Lihat bagian Contoh di halaman ini untuk mengetahui contoh kasus penggunaan ini.
Untuk sebagian besar kasus penggunaan, penajaman adalah alternatif yang lebih sederhana dan rapi untuk extends
.
Developer LookML tingkat lanjut mungkin ingin menggunakan parameter extends
di dalam penyempurnaan LookML. Lihat bagian Penajaman dapat berisi perluasan di halaman ini untuk informasi selengkapnya.
Penajaman mengganti sebagian besar parameter
Penting untuk diperhatikan bahwa dalam kebanyakan kasus, penyempurnaan akan mengganti setelan asli suatu objek. Pada contoh berikut, tampilan asli memiliki dimensi tersembunyi (hidden: yes
):
view: faa_flights {
dimension: carrier {
hidden: yes
}
}
Dan di file lain terdapat penyempurnaan pada dimensi tersebut dengan hidden: no
:
include: "/views/faa_flights.view.lkml"
view: +faa_flights {
dimension: carrier {
hidden: no
}
}
Penyempitan terakhir lebih diutamakan, sehingga hidden: no
diterapkan dan dimensi akan ditampilkan dalam tampilan akhir.
Ada beberapa kasus ketika penajaman bersifat aditif, bukan penggantian. Lihat bagian Beberapa parameter bersifat aditif di halaman ini untuk informasi selengkapnya.
Beberapa parameter bersifat aditif
Dalam banyak kasus, jika penajaman berisi parameter yang sama dengan objek yang disempurnakan, penyempitan akan mengganti nilai parameter objek yang disempurnakan.
Namun, penyempurnaan dapat bersifat tambahan untuk beberapa parameter, yang berarti nilai dari objek dasar digunakan bersama dengan nilai dari objek yang ditingkatkan.
Parameter berikut adalah aditif:
Untuk dimensi dan ukuran:
Untuk parameter:
Untuk tabel turunan:
Untuk tampilan:
extends
(Lihat bagian Penajamanextends
bersifat tambahan di halaman ini untuk mengetahui informasi selengkapnya.)
Untuk Jelajah:
access_filter
aggregate_table
extends
(Lihat bagian Penajamanextends
bersifat tambahan di halaman ini untuk mengetahui informasi selengkapnya.)join
query
Misalnya, berikut adalah tampilan yang memiliki dimensi name
dengan parameter link
:
view: carriers {
sql_table_name: flightstats.carriers ;;
dimension: name {
sql: ${TABLE}.name ;;
type: string
link: {
label: "Google {{ value }}"
url: "http://www.google.com/search?q={{ value }}"
icon_url: "http://google.com/favicon.ico"
}
}
}
Dan berikut adalah penyempurnaan pada tampilan carriers
, dengan dimensi name
yang memiliki nilai berbeda untuk parameter link
:
include: "/views/carriers.view.lkml"
view: +carriers {
label: "Refined carriers"
dimension: name {
sql: ${TABLE}.name ;;
type: string
link: {
label: "Dashboard for {{ value }}"
url: "https://docsexamples.dev.looker.com/dashboards/307?Carrier={{ value }}"
icon_url: "https://www.looker.com/favicon.ico"
}
}
}
Pada tampilan carriers
yang disempurnakan, kedua parameter link
bersifat aditif, sehingga dimensi name
akan menampilkan kedua link.
Penajaman diterapkan secara berurutan
Objek dapat ditingkatkan kualitasnya beberapa kali dan di beberapa tempat, yang memungkinkan developer Looker menggunakan penajaman dengan berbagai cara kreatif. Namun, ini juga berarti developer harus sangat memperhatikan urutan penerapan penyempurnaan:
- Dalam sebuah project, penajaman diterapkan sesuai urutan penyertaan filenya. Penyempitan dari file yang disertakan terakhir akan menggantikan penajaman dari file yang disertakan sebelumnya.
- Dalam satu file, penajaman diterapkan baris demi baris ke bawah. Penyempitan dengan jumlah baris tertinggi akan diterapkan terakhir dan akan menggantikan setiap penajaman sebelumnya, jika ada konflik.
Misalnya, dalam file tampilan berikut ada dua penyempurnaan tampilan faa_flights
. Penyempitan pertama menyembunyikan dimensi (hidden: yes
), dan penajaman kedua menampilkan dimensi (hidden: no
). Jika ada konflik seperti ini, penajaman yang paling bawah dalam file lebih diprioritaskan:
include: "//e_faa_original/views/faa_flights.view.lkml"
view: +faa_flights {
dimension: carrier {
hidden: yes
}
}
view: +faa_flights {
dimension: carrier {
hidden: no
}
}
Logikanya serupa untuk menyertakan beberapa file dalam satu project: Penajaman pada file terakhir yang tercantum dalam penyertaan akan diprioritaskan. Misalnya, jika file model menyertakan file berikut:
include: "/refinements/distance_analysis.lkml"
include: "/refinements/finishing_touches.lkml"
Penyempitan dalam distance_analysis.lkml
akan diterapkan terlebih dahulu, lalu setiap penajaman dalam file finishing_touches.lkml
akan diterapkan. Jika ada konflik, peningkatan pada file terakhir, finishing_touches.lkml
, akan diprioritaskan.
Menggunakan final: yes
untuk mencegah penajaman lebih lanjut
Seperti yang dijelaskan sebelumnya, objek yang sama dapat disempurnakan beberapa kali di beberapa tempat, dan penyempitan terakhir akan menggantikan semua penajaman sebelumnya.
Jika ada penajaman yang ingin dipertimbangkan sebagai penyempurnaan akhir untuk tampilan atau Eksplorasi, Anda dapat menambahkan tanda final: yes
ke penyempurnaan. Looker IDE akan menampilkan error LookML jika ada penyempurnaan yang akan diterapkan setelah penajaman akhir ini, atau jika developer mencoba menambahkan penajaman baru yang akan diterapkan setelah penajaman akhir ini. Misalnya, penajaman kedua dalam file tampilan ini akan menghasilkan error LookML karena penajaman sebelumnya memiliki flag final: yes
:
include: "//e_faa_original/views/faa_flights.view.lkml"
view: +faa_flights {
final: yes
dimension: carrier {
hidden: yes
}
}
view: +faa_flights {
dimension: carrier {
hidden: no
}
}
Menambahkan tanda final: yes
ke penajaman adalah cara yang baik untuk memverifikasi bahwa penajaman Anda diterapkan sesuai urutan yang Anda inginkan.
Penajaman dapat berisi perluasan
Developer LookML tingkat lanjut mungkin ingin menggunakan parameter extends
di dalam penyempurnaan LookML, yang menambahkan objek yang diperluas ke objek yang sedang disempurnakan.
Untuk meringkas perilaku extends
dan penyempurnaan:
- Memperluas objek akan membuat salinan baru objek, lalu melakukan build di atasnya. Misalnya, Anda dapat membuat tampilan dasar yang mendefinisikan semua kolom Anda, lalu membuat beberapa tampilan baru yang memperluas tampilan dasar. Setiap tampilan baru ini akan menggabungkan salinan tampilan dasar, dan dari sana, developer dapat menambahkan kolom, filter, atau properti lain untuk mengubah apa yang ada di tampilan dasar. Idenya adalah Anda memulai dengan objek dasar kemudian menggunakannya dengan cara yang berbeda di beberapa objek lainnya. (Anda dapat melihat halaman dokumentasi Menggunakan kembali kode dengan diperluas untuk diskusi lengkap tentang bekerja dengan ekstensi.)
- Menyaring objek akan menambahkan lapisan modifikasi pada objek, tetapi tidak seperti memperluas, pemurnian tidak membuat banyak salinan objek. Idenya adalah untuk membangun berdasarkan objek dasar tanpa memodifikasi LookML aslinya.
Sebagai contoh penggunaan standar penajaman, berikut adalah Jelajah yang disebut orders
dan Jelajah +orders
yang menyaringnya:
explore: orders {
view_name: orders
# other Explore parameters
}
explore: +orders {
label: "Orders Information"
# other Explore parameters to build on the original Explore
}
Selain itu, Anda dapat menambahkan penajaman yang menyertakan extends
. Berdasarkan contoh tersebut, berikut adalah Jelajah orders
yang sama. Namun selain itu, ada Jelajah dasar yang disebut users_base
, dan kini penajaman +orders
memiliki parameter extends
yang menyertakan users_base
:
explore: users_base {
view_name: users
extension: required
# other Explore parameters
}
explore: orders {
view_name: orders
# other Explore parameters
}
explore: +orders {
label: "Orders Information"
extends: [users_base]
# other Explore parameters to build on the original Explore
}
Yang spesial di sini adalah penajaman +orders
memiliki extends
di dalamnya. Hasilnya adalah tampilan +orders
kini akan memperluas Jelajah users_base
.
Cara Looker menerapkan extends
di dalam penajaman
Memperluas objek di dalam penajaman adalah konsep LookML lanjutan. Sebelum menggunakan extends
dalam penyempurnaan, Anda harus memiliki pemahaman mendalam tentang hal-hal berikut:
- Cara Looker menerapkan
extends
: Jika elemen LookML ditentukan di objek ed dan objek ing yang diperluas, versi dalam objek yang diperluas akan digunakan, kecuali jika parameternya aditif. Lihat halaman dokumentasi Menggunakan kembali kode dengan diperluas untuk mengetahui detailnya. - Cara Looker menerapkan penajaman: Jika elemen LookML ditentukan dalam beberapa penajaman, penajaman terakhir akan menggantikan penajaman sebelumnya. Lihat bagian Penajaman diterapkan secara berurutan di halaman ini untuk mengetahui detailnya.
Terakhir, Anda harus memahami cara Looker menggabungkan prinsip-prinsip ini untuk menerapkan extends
yang digunakan dalam penyempurnaan. Berikut adalah urutan yang diterapkan Looker, dengan setiap langkah menggantikan langkah sebelumnya jika terjadi konflik:
- Nilai dari
extends
yang ditentukan dalam objek - Nilai dari
extends
yang ditentukan dalam penyempurnaan objek - Nilai dari objek
- Nilai dari penyempurnaan objek
Sebagai ilustrasi, berikut adalah contoh yang mengikuti nilai parameter label
melalui setiap langkah implementasi:
explore: orders_base {
label: "Orders Base"
view_name: orders
extension: required
}
explore: users_base {
label: "Users Base"
view_name: users
extension: required
}
explore: orders {
label: "Orders"
extends: [orders_base]
}
explore: +orders {
label: "Orders Refined"
extends: [users_base]
}
Berikut cara Looker menerapkan nilai label
untuk Jelajah orders
dalam contoh ini:
- Nilai dari
extends
yang ditentukan dalam objek. Karena Jelajahorders
memiliki parameterextends
, Looker memulai dengan elemen LookML dari objek yang diperluas, yang dalam hal ini adalah Jelajahorders_base
. Pada tahap ini, nilailabel
adalah "Orders Base". - Nilai dari
extends
yang ditentukan dalam penyempurnaan objek. Karenaorders
memiliki penajaman, dan penajaman memiliki parameterextends
, Looker kemudian akan menerapkan elemen LookML dari ekstensi penajaman, yang dalam hal ini adalah Jelajahusers_base
. Pada tahap ini, nilailabel
adalah "Users Base". - Nilai dari objek. Setelah semua ekstensi diatasi, Looker akan menerapkan elemen dari objek yang diperluas, yang dalam hal ini adalah Jelajah
orders
. Jika ada konflik, objek yang diperluas akan menang. Jadi, nilailabel
sekarang adalah "Orders". - Nilai dari penyempurnaan objek. Terakhir, Looker akan menerapkan elemen dari setiap pengoptimalan dari Jelajah
orders
. Jika ada konflik, objek penajaman akan menang. Jadi, nilailabel
sekarang adalah "Pesanan Disaring".
Penajaman extends
bersifat tambahan
Seperti yang dijelaskan di bagian Penyaringan mengganti parameter di halaman ini, penajaman umumnya mengganti setelan asli objek. Hal ini tidak berlaku untuk parameter extends
. Saat extends
digunakan dalam penyempurnaan, nilai dalam parameter extends
akan ditambahkan ke daftar item yang diperluas di objek asli atau dalam penyempurnaan sebelumnya, jika ada. Kemudian, jika ada konflik, prioritas diberikan ke item terakhir dalam rantai perluasan.
Misalnya, berikut Jelajah dasar yang disebut orders_base
dan Jelajah orders
yang memperluas dasar tersebut. Selain itu, ada Jelajah users_base
dan penajaman +orders
yang memperluas users_base
:
explore: orders_base {
view_name: orders
extension: required
# other Explore parameters
}
explore: users_base {
view_name: users
extension: required
# other Explore parameters
}
explore: orders {
extends: [orders_base]
# other Explore parameters to build on the base Explore
}
explore: +orders {
extends: [users_base]
# other Explore parameters to build on the base Explores
}
Jelajah orders
memperluas orders_base
, lalu penajaman +orders
menambahkan users_base
ke daftar extends
. Hasilnya adalah Jelajah +orders
sekarang akan memperluas orders_base
dan users_base
, seolah-olah ini adalah LookML asli untuk Jelajah tersebut:
explore: orders {
extends: [orders_base, users_base]
}
Kemudian, jika ada konflik, prioritas diberikan ke item terakhir dalam rantai perluasan. Dalam contoh ini, elemen dalam users_base
akan mengganti elemen yang bertentangan di orders_base
.
Konsep memperluas lebih dari satu objek sekaligus dibahas di halaman dokumentasi Menggunakan kembali kode dengan memperluas.
Satu hal terakhir yang perlu diperhatikan: dalam contoh ini, urutan parameter explore
tidak menjadi masalah. Namun, jika ada beberapa penyempurnaan dari objek yang sama, urutan pengoptimalannya penting. Seperti yang dijelaskan di bagian Penajaman diterapkan secara berurutan di halaman ini, penajaman terakhir dalam file akan menggantikan penajaman sebelumnya.
Menggunakan penajaman dalam project LookML
Berikut adalah langkah-langkah umum untuk meningkatkan kualitas tampilan dan Jelajah dalam project Anda:
- Identifikasi tampilan atau Jelajahi yang ingin Anda sempurnakan.
- Tentukan tempat Anda ingin menyimpan penajaman. Anda dapat menambahkan perbaikan dalam file LookML yang sudah ada, atau Anda dapat membuat file LookML terpisah untuk perbaikan Anda. (Lihat prosedur membuat file pengujian data di halaman dokumentasi Memahami file project lainnya untuk contoh pembuatan file LookML umum.)
- Gunakan parameter
include
untuk menerapkan penajaman ke dalam model Anda:- Dalam file tempat Anda menulis perbaikan, Anda harus menyertakan file LookML yang Anda saring. Looker IDE akan memberikan peringatan jika Anda mencoba menyaring objek yang tidak disertakan.
- Dalam file model, sertakan file tempat penyempurnaan Anda ditentukan. Anda dapat menggabungkan file dan penggunaannya mencakup dengan cara yang sangat kreatif; lihat bagian Menggunakan penyempurnaan untuk menambahkan lapisan ke model Anda di halaman ini untuk detailnya.
Contoh
Mempertajam objek LookML adalah cara mudah untuk mengadaptasikan tampilan dan Jelajah tanpa harus mengedit LookML aslinya. Hal ini sangat berguna ketika tampilan dan Jelajah bersifat hanya baca dalam project Anda, misalnya pada file yang diimpor dari project lain. Berikut contoh penyempurnaan fitur Explore.
Berikut adalah LookML untuk Jelajah aircraft
:
explore: aircraft {
join: aircraft_types {
type: left_outer
sql_on: ${aircraft.id} = ${aircraft_types.id} ;;
relationship: many_to_one
}
join: aircraft_engine_types {
type: left_outer
sql_on: ${aircraft.id} = ${aircraft_engine_types.id} ;;
relationship: many_to_one
}
}
Eksplorasi ini berisi beberapa tampilan, yang masing-masing memiliki banyak dimensi.
Sekarang, project LookML lain bernama e_faa_refined
akan mengimpor file Jelajah aircraft
. Dalam project e_faa_refined
, Anda dapat menggunakan penajaman untuk menyederhanakan Jelajah aircraft
secara signifikan.
Karena Jelajah aircraft
adalah file yang diimpor, Anda tidak dapat mengeditnya secara langsung. Sebagai gantinya, Anda dapat menambahkan penajaman ke dalamnya. Berikut adalah contoh file terpisah bernama refinements.lkml
yang berisi LookML ini:
include: "//e_faa_original/Explores/aircraft.explore.lkml"
explore: +aircraft {
label: "Aircraft Simplified"
fields: [aircraft.aircraft_serial, aircraft.name, aircraft.count]
}
File refinements.lkml
berisi hal berikut:
- Parameter
include
untuk menghadirkan fileaircraft.explore.lkml
asli dari project yang diimpor (lihat halaman dokumentasi Mengimpor file dari project lain untuk mengetahui detail tentang cara merujuk ke file project yang diimpor). - Penajaman pada Jelajah
aircraft
:
Hasil akhirnya adalah seolah-olah ini adalah tampilan aircraft
Explore dan aircraft
yang asli:
explore: aircraft {
label: "Aircraft Simplified"
}
view: aircraft {
sql_table_name: flightstats.aircraft ;;
dimension: aircraft_serial {
type: string
sql: ${TABLE}.aircraft_serial ;;
}
dimension: name {
type: string
sql: ${TABLE}.name ;;
}
measure: count {
type: count
}
}
Untuk contoh penggunaan penyempurnaan guna menyesuaikan satu tampilan untuk beberapa kasus penggunaan, lihat resep buku resep Memaksimalkan penggunaan kembali kode dengan DRY LookML: Menyesuaikan satu tampilan dasar untuk beberapa kasus penggunaan.
Kasus penggunaan lainnya untuk penyempurnaan
Seperti yang disebutkan sebelumnya, penajaman ideal untuk menyesuaikan objek LookML yang bersifat hanya baca, seperti Blok Looker atau file yang diimpor.
Namun, begitu Anda bisa menambahkan penyempurnaan dan menyertakannya ke dalam model, Anda bisa melakukan hal-hal yang sangat keren dengan project Anda, seperti yang dijelaskan dalam contoh berikut.
Menggunakan penajaman untuk menambahkan analisis
Anda dapat menggunakan penyempurnaan untuk menambahkan analisis ke model tanpa menyentuh file LookML asli. Misalnya, jika ada project dengan tampilan dan Jelajah yang dihasilkan dari tabel dalam database Anda dan disimpan dalam file LookML bernama faa_basic.lkml
, Anda dapat membuat file faa_analysis.lkml
tempat Anda menggunakan penyempurnaan untuk menambahkan analisis. Berikut contoh tabel turunan baru bernama distance_stats
yang memiliki analisis jarak. Contoh ini menunjukkan penyempurnaan dari Jelajah flights
yang ada dari file faa_basic.lkml
yang menggabungkan tabel turunan distance_stats
ke dalam Jelajah flights
. Selain itu, di bagian bawah contoh, tampilan flights
yang ada disempurnakan untuk menambahkan kolom baru dari analisis:
include: "faa_basic.lkml"
explore: +flights {
join: distance_stats {
relationship: one_to_one
type: cross
}
}
view: distance_stats {
derived_table: {
explore_source: flights {
bind_all_filters: yes
column: distance_avg {field:flights.distance_avg}
column: distance_stddev {field:flights.distance_stddev}
}
}
dimension: avg {
type:number
sql: CAST(${TABLE}.distance_avg as INT64) ;;
}
dimension: stddev {
type:number
sql: CAST(${TABLE}.distance_stddev as INT64) ;;
}
}
view: +flights {
measure: distance_avg {
type: average
sql: ${distance} ;;
}
measure: distance_stddev {
type: number
sql: STDDEV(${distance}) ;;
}
dimension: distance_tiered2 {
type: tier
sql: ${distance} ;;
tiers: [500,1300]
}
}
Menggunakan penajaman untuk menambahkan lapisan ke model Anda
Kasus penggunaan menarik lainnya untuk penyempurnaan adalah menambahkan lapisan ke project Anda. Anda dapat membuat beberapa file penyempurnaan, lalu menyertakannya secara strategis untuk menambahkan lapisan.
Misalnya, dalam project FAA ada file faa_raw.lkml
yang berisi semua tampilan dan Jelajah yang dihasilkan dari tabel di database Anda. File ini memiliki tampilan untuk setiap tabel dalam database, masing-masing dengan dimensi untuk setiap kolom database.
Selain file mentah, Anda dapat membuat file faa_basic.lkml
untuk menambahkan lapisan baru dengan peningkatan dasar, seperti menambahkan gabungan ke Jelajah, atau menambahkan ukuran ke tampilan, seperti ini:
include: "faa_raw.lkml"
explore: +flights {
join: carriers {
sql_on: ${flights.carrier} = ${carriers.name} ;;
}
}
view: +flights {
measure: total_seats {
type: sum
sql: ${aircraft_models.seats} ;;
}
}
Selanjutnya, Anda dapat menambahkan file faa_analysis.layer.lkml
untuk menambahkan lapisan baru dengan analisis (lihat subbagian Menggunakan penyempurnaan untuk menambahkan analisis untuk mengetahui contoh file analisis).
Dari sana, Anda hanya perlu menyertakan semua file perbaikan ke dalam file model. Anda juga dapat menggunakan file model untuk menambahkan penyempurnaan guna mengarahkan tampilan Anda ke tabel database yang ingin direferensikan:
connection: "publicdata_standard_sql"
include: "faa_raw.lkml"
include: "faa_basic.lkml"
include: "faa_analysis.lkml"
view: +flights {
sql_table_name: lookerdata.faa.flights;;
}
view: +airports {
sql_table_name: lookerdata.faa.airports;;
}
view: +aircraft {
sql_table_name: lookerdata.faa.aircraft;;
}
view: +aircraft_models{
sql_table_name: lookerdata.faa.aircraft_models;;
}
view: +carriers {
sql_table_name: lookerdata.faa.carriers;;
}
Anda bisa menduplikasi file model ini dan menunjuk ke tabel database yang berbeda, atau Anda bisa menyertakan file penajaman yang berbeda yang telah Anda buat untuk menetapkan lapisan lain yang Anda inginkan dalam model Anda.
Menggunakan penajaman untuk PDT
Seperti yang dijelaskan di bagian Penajaman dibandingkan dengan diperluas di halaman ini, ekstensi akan membuat salinan baru dari objek yang sedang diperluas. Dalam kasus tabel turunan persisten (PDT), Anda tidak boleh menggunakan ekstensi, karena setiap ekstensi PDT akan membuat salinan tabel baru di database Anda.
Namun, Anda dapat menambahkan penyempurnaan ke tampilan PDT, karena penajaman tidak membuat salinan baru dari objek yang sedang disempurnakan.
Menggunakan metadata untuk melihat penyempurnaan suatu objek
Anda dapat mengklik parameter explore
atau view
di Looker IDE dan menggunakan panel metadata untuk melihat penajaman pada objek. Lihat halaman dokumentasi Metadata untuk objek LookML untuk mengetahui informasinya.
Hal-hal yang perlu dipertimbangkan
Project dengan pelokalan
Saat Anda menyaring objek, perhatikan bahwa aturan pelokalan juga berlaku untuk penyempurnaan Anda. Jika Anda menyempurnakan objek lalu menentukan label atau deskripsi baru, Anda harus memberikan definisi pelokalan dalam file string lokalitas project Anda. Lihat halaman dokumentasi Melokalkan model LookML untuk informasi selengkapnya.