Penajaman LookML

Ringkasan

Dengan peningkatan LookML, Anda dapat menyesuaikan tampilan atau Jelajahi yang ada tanpa mengedit file LookML yang berisinya. Hal ini sangat cocok 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 dalam contoh berikut: Gunakan parameter view dengan nama tampilan yang sama, tetapi tambahkan tanda plus (+) di depan nama untuk menunjukkan bahwa tampilan tersebut merupakan penyempurnaan dari tampilan yang ada.

Penyempurnaan ini menambahkan dimensi air_carrier ke tampilan flights yang ada:

view: +flights {
  dimension: air_carrier {
    type: string
    sql: ${TABLE}.air_carrier ;;
  }
 }

Penyempurnaan ini dapat ditempatkan di file LookML apa pun dalam project, seperti file model, file tampilan, atau dalam file LookML khusus. Lihat bagian Menggunakan penyempurnaan dalam project LookML untuk mengetahui cara kerjanya.

Penyempurnaan 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 Maskapai Penerbangan, sama seperti jika Anda telah menambahkan dimensi ke file tampilan asli itu sendiri.

Lihat bagian Contoh untuk informasi penerapan yang lebih mendetail.

Peningkatan dibandingkan dengan ekstensi

Looker juga mendukung memperluas objek LookML. Perluasan berguna saat Anda ingin membuat salinan baru dari tampilan atau Jelajahi yang ada sehingga Anda dapat menambahkan objek baru ke dalamnya. Misalnya, Anda dapat membuat tampilan dasar yang menentukan semua kolom, lalu membuat beberapa tampilan baru yang memperluas tampilan dasar. Tampilan baru ini kemudian dapat diubah untuk menyembunyikan kolom tertentu di tampilan dasar, atau untuk mengubah definisi atau label untuk kolom dari tampilan dasar.

Penyempurnaan berguna jika Anda ingin mengubah tampilan atau Jelajah yang ada dengan beberapa penyesuaian atau perubahan pada objek tertentu, tetapi tidak ingin membuat salinan tampilan atau Jelajah. Penyempurnaan ideal untuk situasi saat Anda tidak dapat atau tidak ingin mengubah tampilan dasar atau Jelajah, dan untuk situasi saat membuat tampilan atau Jelajah baru akan memerlukan perubahan yang ekstensif pada referensi LookML lainnya. Lihat bagian Contoh di halaman ini untuk mengetahui contoh kasus penggunaan ini.

Untuk sebagian besar kasus penggunaan, peningkatan adalah alternatif yang lebih sederhana dan lebih bersih untuk extends.

Developer LookML lanjutan mungkin ingin menggunakan parameter extends di dalam penyempurnaan LookML. Lihat bagian Penyesuaian dapat berisi ekstensi di halaman ini untuk mengetahui informasi selengkapnya.

Penyempurnaan mengganti sebagian besar parameter

Perlu diperhatikan bahwa dalam sebagian besar kasus, pengoptimalan akan mengganti setelan asli objek. Pada contoh berikut, tampilan asli memiliki dimensi tersembunyi (hidden: yes):

view: faa_flights {
  dimension: carrier {
    hidden: yes
  }
}

Dan dalam file lain, ada peningkatan pada dimensi tersebut dengan hidden: no:


include: "/views/faa_flights.view.lkml"

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

Penyempurnaan terakhir lebih diutamakan, sehingga hidden: no diterapkan dan dimensi akan ditampilkan dalam tampilan akhir.

Ada beberapa kasus saat penyempurnaan bersifat aditif, bukan menggantikan; lihat bagian Beberapa parameter bersifat aditive di halaman ini untuk mengetahui informasi selengkapnya.

Beberapa parameter bersifat aditive

Dalam banyak kasus, jika penyempurnaan berisi parameter yang sama dengan objek yang sedang ditingkatkan, penyempurnaan akan mengganti nilai parameter objek yang ditingkatkan.

Namun, peningkatan dapat bersifat aditif untuk beberapa parameter, yang berarti bahwa nilai dari objek dasar digunakan bersama dengan nilai dari objek yang ditingkatkan.

Parameter berikut bersifat 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"
    }
  }
}

Berikut adalah peningkatan 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"
    }
  }
}

Dalam tampilan carriers yang dioptimalkan, kedua parameter link bersifat aditive, sehingga dimensi name akan menampilkan kedua link.

Penyempurnaan diterapkan secara berurutan

Objek dapat dioptimalkan beberapa kali dan di beberapa tempat, sehingga developer Looker dapat menggunakan pengoptimalan dengan banyak cara kreatif. Namun, hal ini juga berarti bahwa developer harus sangat memperhatikan urutan penerapan peningkatan:

  • Dalam project, penyempurnaan diterapkan sesuai urutan file disertakan. Penyempurnaan dari file yang disertakan terakhir akan mengganti penyempurnaan dari file yang disertakan sebelumnya.
  • Dalam satu file, peningkatan diterapkan baris demi baris ke bawah. Penyempurnaan dengan nomor baris tertinggi diterapkan terakhir dan akan mengganti penyempurnaan sebelumnya, jika ada konflik.

Misalnya, dalam file tampilan berikut, ada dua peningkatan tampilan faa_flights. Penyempurnaan pertama menyembunyikan dimensi (hidden: yes), dan penyempurnaan kedua menampilkan dimensi (hidden: no). Jika ada konflik seperti ini, penyempurnaan yang paling jauh di file akan 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 project: Penyempurnaan dalam file terakhir yang tercantum dalam include akan diprioritaskan. Misalnya, jika file model menyertakan file berikut:

include: "/refinements/distance_analysis.lkml"
include: "/refinements/finishing_touches.lkml"

Setiap peningkatan kualitas di distance_analysis.lkml akan diterapkan terlebih dahulu, lalu setiap peningkatan kualitas di file finishing_touches.lkml akan diterapkan. Jika ada konflik, peningkatan kualitas dalam file terakhir, finishing_touches.lkml, akan diprioritaskan.

Menggunakan final: yes untuk mencegah penyempurnaan lebih lanjut

Seperti yang dijelaskan sebelumnya, objek yang sama dapat diperbaiki beberapa kali di beberapa tempat, dan peningkatan terakhir akan mengganti semua peningkatan sebelumnya.

Jika memiliki penyempurnaan yang ingin dianggap sebagai penyempurnaan akhir untuk tampilan atau Jelajahi, Anda dapat menambahkan tanda final: yes ke penyempurnaan. IDE Looker akan menampilkan error LookML jika ada penajaman yang akan diterapkan setelah penajaman akhir ini, atau jika developer mencoba menambahkan penajaman baru yang akan diterapkan setelah penajaman akhir ini. Misalnya, penyempurnaan kedua dalam file tampilan ini akan membuat error LookML karena penyempurnaan sebelumnya memiliki tanda 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 perincian adalah cara yang baik untuk memverifikasi bahwa perincian Anda diterapkan dalam urutan yang Anda inginkan.

Penyempurnaan dapat berisi ekstensi

Developer LookML lanjutan mungkin ingin menggunakan parameter extends di dalam penyempurnaan LookML, yang menambahkan objek yang diperluas ke objek yang sedang ditingkatkan.

Untuk meringkas perilaku extends dan peningkatan:

  • Memperluas objek akan membuat salinan baru objek, lalu mem-build-nya. Misalnya, Anda dapat membuat tampilan dasar yang menentukan semua kolom, lalu membuat beberapa tampilan baru yang memperluas tampilan dasar. Setiap tampilan baru ini akan menggabungkan salinan tampilan dasar, dan dari sana developer dapat menambahkan berbagai kolom, filter, atau properti lainnya untuk mengubah tampilan dasar. Idenya adalah Anda memulai dengan objek dasar, lalu menggunakannya dengan cara yang berbeda di beberapa objek lainnya. (Anda dapat melihat halaman dokumentasi Menggunakan kembali kode dengan ekstensi untuk diskusi lengkap tentang cara menggunakan ekstensi.)
  • Meningkatkan kualitas objek akan menambahkan lapisan modifikasi ke objek, tetapi, tidak seperti memperluas, meningkatkan kualitas tidak membuat beberapa salinan objek. Idenya adalah membuat objek dasar tanpa mengubah LookML aslinya.

Sebagai contoh penggunaan standar penajaman, berikut adalah Eksplorasi yang disebut orders dan Eksplorasi +orders yang mempertajamnya:

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 penyempurnaan yang menyertakan extends. Berdasarkan contoh tersebut, berikut adalah Eksplorasi orders yang sama. Namun, selain itu, ada Jelajah dasar yang disebut users_base, dan sekarang penyempurnaan +orders memiliki parameter extends yang menampilkan 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 istimewa di sini adalah penyempurnaan +orders memiliki extends di dalamnya. Hasilnya adalah tampilan +orders kini akan memperluas users_base Jelajahi.

Cara Looker menerapkan extends di dalam penyempurnaan

Memperluas objek di dalam penyempurnaan adalah konsep LookML lanjutan. Sebelum menggunakan extends dalam penyempurnaan, Anda harus memiliki pemahaman mendalam tentang hal berikut:

  • Cara Looker menerapkan extends: Jika elemen LookML ditentukan dalam objek yang diperluas dan objek yang memperluas, versi dalam objek yang memperluas akan digunakan, kecuali jika parameternya aditif. Lihat halaman dokumentasi Menggunakan kembali kode dengan ekstensi untuk mengetahui detailnya.
  • Cara Looker menerapkan penajaman: Jika elemen LookML ditentukan dalam beberapa penajaman, penajaman terakhir akan menggantikan penajaman sebelumnya. Lihat bagian Penyesuaian 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 peningkatan kualitas objek

Untuk mengilustrasikan, berikut adalah contoh yang mengikuti nilai parameter label melalui setiap langkah penerapan:

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 Eksplorasi orders dalam contoh ini:

  1. Nilai dari extends yang ditentukan dalam objek. Karena Jelajah orders memiliki parameter extends, Looker akan dimulai 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 penyempurnaan, dan penyempurnaan memiliki parameter extends, Looker kemudian menerapkan elemen LookML dari ekstensi penyempurnaan, yang dalam hal ini adalah Jelajah users_base. Pada tahap ini, nilai label adalah "Users Base".
  3. Nilai dari objek. Setelah semua ekstensi ditangani, Looker akan menerapkan elemen dari objek yang diperluas, yang dalam hal ini adalah orders Jelajahi. Jika ada konflik, objek yang diperluas akan menang. Jadi, sekarang nilai label adalah "Pesanan".
  4. Nilai dari penyempurnaan objek. Terakhir, Looker menerapkan elemen dari setiap peningkatan orders Jelajah. Jika ada konflik, objek perincian akan menang. Jadi, sekarang nilai label adalah "Pesanan Disempurnakan".

Penajaman extends bersifat kumulatif

Seperti yang dijelaskan di bagian Parameter penggantian penyempurnaan di halaman ini, penyempurnaan umumnya mengganti setelan asli objek. Hal ini tidak berlaku untuk parameter extends. Jika extends digunakan dalam penyempurnaan, nilai dalam parameter extends akan ditambahkan ke daftar item yang diperluas dalam objek asli atau dalam penyempurnaan sebelumnya, jika ada. Kemudian, jika ada konflik, prioritas diberikan ke item terakhir dalam rantai ekstensi.

Misalnya, berikut adalah Eksplorasi dasar yang disebut orders_base dan Eksplorasi orders yang memperluas dasar. Selain itu, ada Jelajahi users_base dan penyempurnaan +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
}

Jelajahi orders memperluas orders_base, lalu perincian +orders menambahkan users_base ke daftar extends. Hasilnya adalah Eksplorasi +orders kini akan memperluas orders_base dan users_base, seolah-olah ini adalah LookML asli untuk Eksplorasi:

explore: orders {
  extends: [orders_base, users_base]
}

Kemudian, jika ada konflik, prioritas diberikan ke item terakhir dalam rantai ekstensi. Dalam contoh ini, elemen di 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 extends.

Satu hal terakhir yang perlu diperhatikan: dalam contoh ini, urutan parameter explore tidak akan berpengaruh. Namun, dalam kasus dengan beberapa perincian objek yang sama, urutan perinciannya memang penting. Seperti yang dijelaskan di bagian Penyesuaian diterapkan secara berurutan di halaman ini, penyesuaian terakhir dalam file akan menggantikan penyesuaian sebelumnya.

Menggunakan penajaman dalam project LookML

Berikut adalah langkah-langkah umum untuk meningkatkan kualitas tampilan dan Jelajah di project Anda:

  1. Identifikasi tampilan atau Jelajahi yang ingin Anda pertajam.
  2. Tentukan tempat Anda ingin menyimpan penyempurnaan. Anda dapat menambahkan penyempurnaan dalam file LookML yang ada, atau membuat file LookML terpisah untuk penyempurnaan. (Lihat prosedur untuk membuat file pengujian data di halaman dokumentasi Memahami file project lainnya untuk mengetahui contoh pembuatan file LookML umum.)
  3. Gunakan parameter include untuk menggabungkan penyempurnaan ke dalam model Anda:
    • Dalam file tempat Anda menulis penyempurnaan, Anda harus menyertakan file LookML yang sedang Anda sempurnakan. IDE Looker akan memberi Anda peringatan jika Anda mencoba menyaring objek yang tidak disertakan.
    • Dalam file model, sertakan file tempat penyempurnaan Anda ditentukan. Anda dapat menggabungkan file dan menggunakan include dengan cara yang sangat kreatif; lihat bagian Menggunakan penyempurnaan untuk menambahkan lapisan ke model Anda di halaman ini untuk mengetahui detailnya.

Contoh

Meningkatkan kualitas objek LookML adalah cara mudah untuk menyesuaikan tampilan dan Jelajah tanpa harus mengedit LookML asli. Hal ini sangat berguna jika tampilan dan Jelajah Anda hanya dapat dibaca di project, seperti dengan file yang diimpor dari project lain. Berikut adalah contoh untuk menyaring Jelajah.

Berikut adalah LookML untuk Eksplorasi 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 yang disebut e_faa_refined mengimpor file Eksplorasi aircraft. Dalam project e_faa_refined, Anda dapat menggunakan penyempurnaan untuk menyederhanakan aircraft Jelajah secara drastis.

Karena aircraft Explore adalah file yang diimpor, Anda tidak dapat mengeditnya secara langsung. Sebagai gantinya, Anda dapat menambahkan perincian ke dalamnya. Berikut adalah contoh file terpisah yang disebut 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 memasukkan 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).
  • Peningkatan pada Jelajahi aircraft:
    • Tanda + di depan nama Jelajah menunjukkan penajaman pada Jelajah yang ada.
    • Parameter label mengubah label Jelajah menjadi "Pesawat Sederhana".
    • Parameter fields menentukan bahwa hanya tiga kolom yang akan ditampilkan di Jelajahi.

Hasil akhirnya akan terlihat seperti tampilan aircraft Jelajahi dan aircraft 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 penyesuaian untuk menyesuaikan satu tampilan untuk beberapa kasus penggunaan, lihat resep cookbook Memaksimalkan penggunaan kembali kode dengan DRY LookML: Menyesuaikan satu tampilan dasar untuk beberapa kasus penggunaan.

Kasus penggunaan lainnya untuk peningkatan

Seperti yang disebutkan sebelumnya, penyesuaian sangat cocok untuk menyesuaikan objek LookML yang hanya dapat dibaca, seperti Looker Blocks atau file yang diimpor.

Namun, setelah Anda memahami cara menambahkan peningkatan dan menyertakannya dalam model, Anda dapat melakukan hal-hal yang sangat keren dengan project Anda, seperti yang dijelaskan dalam contoh berikut.

Menggunakan penyempurnaan untuk menambahkan analisis

Anda dapat menggunakan penyempurnaan untuk menambahkan analisis ke model tanpa menyentuh file LookML asli. Misalnya, jika ada project tempat tampilan dan Jelajah dibuat dari tabel dalam database Anda dan disimpan dalam file LookML bernama faa_basic.lkml, Anda dapat membuat file faa_analysis.lkml tempat Anda menggunakan penyesuaian untuk menambahkan analisis. Berikut adalah contoh tabel turunan baru yang disebut distance_stats yang memiliki analisis jarak. Contoh ini menunjukkan peningkatan flights Jelajah yang ada dari file faa_basic.lkml yang menggabungkan tabel turunan distance_stats ke dalam flights Jelajah. Selain itu, di bagian bawah contoh, tampilan flights yang ada dioptimalkan 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 penyempurnaan untuk menambahkan lapisan ke model Anda

Kasus penggunaan menarik lainnya untuk peningkatan adalah menambahkan lapisan ke project Anda. Anda dapat membuat beberapa file perbaikan, lalu menyertakannya secara strategis untuk menambahkan lapisan.

Misalnya, dalam project FAA, ada file faa_raw.lkml yang berisi semua tampilan dan Jelajah yang dibuat dari tabel dalam 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 penyempurnaan dasar, seperti menambahkan join 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 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 ke tabel database yang ingin dirujuk:

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 dapat menduplikasi file model ini dan mengarahkannya ke tabel database yang berbeda, atau menyertakan file peningkatan yang berbeda yang telah Anda buat untuk menentukan lapisan lain yang Anda inginkan dalam model.

Menggunakan penyempurnaan untuk PDT

Seperti yang dijelaskan di bagian Pembaruan dibandingkan dengan ekstensi di halaman ini, ekstensi membuat salinan baru objek yang diperluas. Untuk tabel turunan persisten (PDT), Anda tidak boleh menggunakan ekstensi, karena setiap ekstensi PDT akan membuat salinan baru tabel di database Anda.

Namun, Anda dapat menambahkan penyempurnaan ke tampilan PDT, karena penyempurnaan tidak membuat salinan baru objek yang sedang ditingkatkan.

Menggunakan metadata untuk melihat penyempurnaan objek

Anda dapat mengklik parameter explore atau view di Looker IDE dan menggunakan panel metadata untuk melihat peningkatan 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 penyaringan Anda. Jika Anda menyaring objek, lalu menentukan label atau deskripsi baru, Anda harus memberikan definisi pelokalan dalam file string lokalitas project. Lihat halaman dokumentasi Menlokalkan model LookML untuk mengetahui informasi selengkapnya.