Penajaman LookML

Ringkasan

Dengan penyempurnaan LookML, Anda dapat menyesuaikan tampilan atau Eksplorasi yang ada tanpa mengedit file LookML yang memuatnya. Fitur ini sangat cocok untuk:

Misalnya, jika Anda memiliki file tampilan berikut dalam project Anda:

view: flights {
  sql_table_name: flightstats.accidents ;;

  dimension: id {
    label: "id"
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
}

Anda dapat menyempurnakan 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 ini adalah penyempurnaan 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 dilakukan dalam file LookML apa pun dalam project, seperti file model, file tampilan, atau dalam file LookML khusus. Lihat bagian Menggunakan penyempurnaan dalam project LookML Anda untuk mengetahui cara kerjanya.

Penyempurnaan yang digabungkan 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, seolah-olah Anda telah menambahkan dimensi tersebut ke file tampilan asli.

Lihat bagian Contoh untuk informasi penerapan yang lebih mendetail.

Penyempurnaan dibandingkan dengan perluasan

Looker juga mendukung perluasan objek LookML. Memperluas berguna saat Anda ingin membuat salinan baru dari tampilan atau Eksplorasi 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 dalam tampilan dasar, atau untuk mengubah definisi atau label kolom dari tampilan dasar.

Penyempurnaan berguna saat Anda ingin mengubah tampilan atau Jelajah yang ada dengan beberapa penyesuaian atau perubahan pada objek tertentu, tetapi Anda 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 ekstensif pada referensi LookML lainnya. Lihat bagian Contoh di halaman ini untuk melihat contoh kasus penggunaan ini.

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

Developer LookML tingkat lanjut mungkin ingin menggunakan parameter extends di dalam penyempurnaan LookML. Lihat bagian Penyempurnaan dapat berisi perluasan di halaman ini untuk mengetahui informasi selengkapnya.

Penyempurnaan menggantikan sebagian besar parameter

Penting untuk diperhatikan bahwa dalam sebagian besar kasus, penyempurnaan akan menggantikan setelan asli objek. Dalam contoh berikut, tampilan asli memiliki dimensi tersembunyi (hidden: yes):

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

Di file lain, ada penyempurnaan 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 di tampilan akhir.

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

Beberapa parameter bersifat aditif

Dalam banyak kasus, jika penyempurnaan berisi parameter yang sama dengan objek yang disempurnakan, penyempurnaan akan menggantikan nilai parameter objek yang disempurnakan.

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

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 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"
    }
  }
}

Dalam tampilan carriers yang disempurnakan, dua parameter link bersifat aditif, sehingga dimensi name akan menampilkan kedua link.

Penyempurnaan diterapkan secara berurutan

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

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

Misalnya, dalam file tampilan berikut, ada dua penyempurnaan tampilan faa_flights. Penyempurnaan pertama menyembunyikan dimensi (hidden: yes), dan penyempurnaan kedua menampilkan dimensi (hidden: no). Jika ada konflik seperti ini, penyempurnaan yang paling bawah dalam 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"

Penyempurnaan apa pun di distance_analysis.lkml akan diterapkan terlebih dahulu, lalu penyempurnaan apa pun di file finishing_touches.lkml akan diterapkan. Jika ada konflik, penyempurnaan dalam file terakhir, finishing_touches.lkml, akan diutamakan.

Menggunakan final: yes untuk mencegah penyempurnaan lebih lanjut

Seperti yang dijelaskan sebelumnya, objek yang sama dapat disempurnakan beberapa kali di beberapa tempat, dan penyempurnaan terakhir akan menggantikan semua penyempurnaan sebelumnya.

Jika Anda 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 ada 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 menghasilkan 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 penyempurnaan adalah cara yang baik untuk memverifikasi bahwa penyempurnaan Anda diterapkan dalam urutan yang Anda inginkan.

Penyempurnaan dapat berisi perluasan

Developer LookML tingkat lanjut mungkin ingin menggunakan parameter extends 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 membangunnya. Misalnya, Anda dapat membuat tampilan dasar yang menentukan semua kolom, lalu membuat beberapa tampilan baru yang memperluas tampilan dasar. Setiap tampilan baru ini akan menyertakan salinan tampilan dasar, dan dari sana developer dapat menambahkan berbagai kolom, filter, atau properti lain untuk mengubah konten dalam tampilan dasar. Idenya adalah Anda memulai dengan objek dasar, lalu menggunakannya dengan berbagai cara di beberapa objek lainnya. (Anda dapat melihat halaman dokumentasi Menggunakan kembali kode dengan ekstensi untuk pembahasan lengkap tentang cara menggunakan ekstensi.)
  • Memperbaiki objek akan menambahkan lapisan modifikasi pada objek, tetapi, tidak seperti memperluas, memperbaiki tidak membuat beberapa salinan objek. Idenya adalah membangun objek dasar tanpa mengubah LookML aslinya.

Sebagai contoh penggunaan penyempurnaan standar, berikut adalah Eksplorasi yang disebut orders dan Eksplorasi +orders yang menyempurnakannya:

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, berikut adalah Eksplorasi orders yang sama. Namun, selain itu, ada Jelajah dasar yang disebut users_base, dan kini 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 Eksplorasi users_base.

Cara Looker menerapkan extends di dalam penyempurnaan

Memperluas objek di dalam penyempurnaan adalah konsep LookML lanjutan. Sebelum menggunakan extends dalam penyempurnaan, Anda harus memahami hal-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 extends untuk mengetahui detailnya.
  • Cara Looker menerapkan penajaman: Jika elemen LookML ditentukan dalam beberapa penajaman, penajaman terakhir akan menggantikan penajaman sebelumnya. Lihat bagian Penyempurnaan 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 penerapan 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

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 Eksplorasi orders memiliki parameter extends, Looker dimulai dengan elemen LookML dari objek yang diperluas, yang dalam hal ini adalah Eksplorasi 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 Eksplorasi. Jika ada konflik, objek yang memperluas akan menang. Jadi sekarang, nilai label adalah "Orders".
  4. Nilai dari penyempurnaan objek. Terakhir, Looker menerapkan elemen dari penyempurnaan orders Explore. Jika ada konflik, objek penyempurnaan akan menang. Jadi, nilai label sekarang adalah "Pesanan yang Diperbaiki".

Penajaman extends bersifat menambah

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

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

orders Explore memperluas orders_base, lalu penyempurnaan +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 kepada item terakhir dalam rantai perluasan. Dalam contoh ini, elemen di users_base akan menggantikan 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 penyempurnaan objek yang sama, urutan penyempurnaan penting. Seperti yang dijelaskan di bagian Penyempurnaan diterapkan secara berurutan di halaman ini, penyempurnaan terakhir dalam file akan menggantikan penyempurnaan sebelumnya.

Menggunakan penajaman dalam project LookML Anda

Berikut adalah langkah-langkah umum untuk menyempurnakan tampilan dan Eksplorasi dalam project Anda:

  1. Identifikasi tampilan atau Eksplorasi yang ingin Anda pertajam.
  2. Tentukan tempat Anda ingin menempatkan 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 melihat contoh pembuatan file LookML generik.)
  3. Gunakan parameter include untuk menggabungkan penyempurnaan ke dalam model Anda:
    • Dalam file tempat Anda menuliskan penyempurnaan, Anda harus menyertakan file LookML yang Anda sempurnakan. IDE Looker akan memberi Anda peringatan jika Anda mencoba menyempurnakan 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 penyesuaian untuk menambahkan lapisan ke model Anda di halaman ini untuk mengetahui detailnya.

Contoh

Memperbaiki objek LookML adalah cara mudah untuk menyesuaikan tampilan dan Eksplorasi tanpa harus mengedit LookML asli. Hal ini sangat berguna saat tampilan dan Eksplorasi Anda bersifat hanya baca di project, seperti file yang diimpor dari project lain. Berikut adalah contoh penyempurnaan Eksplorasi.

Berikut 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 bernama e_faa_refined mengimpor file Eksplorasi aircraft. Dalam project e_faa_refined, Anda dapat menggunakan penyempurnaan untuk menyederhanakan Eksplorasi aircraft secara signifikan.

Karena Eksplorasi aircraft adalah file yang diimpor, Anda tidak dapat mengeditnya secara langsung. Sebagai gantinya, Anda dapat menambahkan penyempurnaan 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 memunculkan file aircraft.explore.lkml asli dari project yang diimpor (lihat halaman dokumentasi Mengimpor file dari project lain untuk mengetahui detail cara merujuk ke file project yang diimpor).
  • Penyempurnaan pada Jelajahi aircraft:
    • Tanda + di depan nama Jelajah menunjukkan penajaman pada Jelajah yang ada.
    • Parameter label mengubah label Explore menjadi "Aircraft Simplified".
    • Parameter fields menentukan bahwa hanya tiga kolom yang akan ditampilkan di Eksplorasi.

Hasil akhirnya seolah-olah ini adalah tampilan Jelajahi dan aircraft asli:aircraft

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 cookbook Memaksimalkan penggunaan kembali kode dengan DRY LookML: Menyesuaikan satu tampilan dasar untuk beberapa kasus penggunaan.

Kasus penggunaan lain untuk penyempurnaan

Seperti yang disebutkan sebelumnya, penyempurnaan sangat ideal untuk mengadaptasi objek LookML yang bersifat hanya baca, seperti Blok Looker atau file yang diimpor.

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

Menggunakan penyesuaian untuk menambahkan analisis

Anda dapat menggunakan penyempurnaan untuk menambahkan analisis ke model tanpa menyentuh file LookML asli. Misalnya, jika ada project yang tampilan dan Eksplorasinya 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 penyempurnaan untuk menambahkan analisis. Berikut adalah contoh tabel turunan baru bernama distance_stats yang memiliki analisis jarak. Contoh ini menunjukkan penyempurnaan flights Jelajah 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 penyempurnaan untuk menambahkan lapisan ke model Anda

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

Misalnya, dalam project FAA, ada file faa_raw.lkml yang berisi semua tampilan dan Eksplorasi 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 gabungan ke Eksplorasi, 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} ;;
  }
}

Kemudian, Anda dapat menambahkan file faa_analysis.layer.lkml untuk menambahkan lapisan baru dengan analisis (lihat subbagian Menggunakan penyesuaian untuk menambahkan analisis untuk melihat contoh file analisis).

Dari sana, Anda hanya perlu menyertakan semua file penyempurnaan ke dalam file model. Anda juga dapat menggunakan file model untuk menambahkan penyempurnaan guna mengarahkan tampilan ke tabel database yang ingin Anda referensikan:

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 penyesuaian berbeda yang telah Anda buat untuk menentukan lapisan lain yang Anda inginkan dalam model.

Menggunakan penyempurnaan untuk PDT

Seperti yang dijelaskan di bagian Penyempurnaan dibandingkan dengan perluasan di halaman ini, ekstensi membuat salinan baru objek yang 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 pada tampilan PDT, karena penyempurnaan tidak membuat salinan baru dari objek yang disempurnakan.

Menggunakan metadata untuk melihat perbaikan objek

Anda dapat mengklik parameter explore atau view di Looker IDE dan menggunakan panel metadata untuk melihat penyempurnaan pada objek. Lihat halaman dokumentasi Metadata untuk objek LookML untuk mengetahui informasi.

Hal-hal yang perlu dipertimbangkan

Project dengan pelokalan

Saat Anda menyempurnakan objek, perlu diketahui 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 bahasa project Anda. Lihat halaman dokumentasi Melokalkan model LookML Anda untuk mengetahui informasi selengkapnya.