Penajaman LookML

Ringkasan

Dengan penyempurnaan LookML, Anda dapat menyesuaikan tampilan atau Explore yang ada tanpa mengedit file LookML yang memuatnya. Ini ideal untuk:

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:

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:

  1. Nilai dari extends yang ditentukan dalam objek
  2. Nilai dari extends yang ditentukan dalam penyempurnaan objek
  3. Nilai dari objek
  4. 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:

  1. Nilai dari extends yang ditentukan dalam objek. Karena Jelajah orders memiliki parameter extends, Looker memulai dengan elemen LookML dari objek yang diperluas, yang dalam hal ini adalah Jelajah orders_base. Pada tahap ini, nilai label adalah "Orders Base".
  2. Nilai dari extends yang ditentukan dalam penyempurnaan objek. Karena orders memiliki penajaman, dan penajaman memiliki parameter extends, Looker kemudian akan menerapkan elemen LookML dari ekstensi penajaman, yang dalam hal ini adalah Jelajah users_base. Pada tahap ini, nilai label adalah "Users Base".
  3. 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, nilai label sekarang adalah "Orders".
  4. Nilai dari penyempurnaan objek. Terakhir, Looker akan menerapkan elemen dari setiap pengoptimalan dari Jelajah orders. Jika ada konflik, objek penajaman akan menang. Jadi, nilai label 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:

  1. Identifikasi tampilan atau Jelajahi yang ingin Anda sempurnakan.
  2. 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.)
  3. 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 file aircraft.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:
    • Tanda + di depan nama Jelajah menunjukkan penyempurnaan pada Jelajah yang ada.
    • Parameter label mengubah label Explore menjadi "Pesawat Sederhana".
    • Parameter fields menentukan bahwa hanya tiga kolom yang akan ditampilkan di Eksplorasi.

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.