Anda melihat dokumentasi untuk Looker 26.14. Klik link ini untuk melihat dokumentasi terbaru.

Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

derived_analytic_model

Penggunaan

# SQL-based derived analytic model
view: view_name {
  derived_analytic_model: {
    publish_as_db_analytic_model: yes | no
    sql: analytic_model_definition ;;
  }
}

# LookML-based derived analytic model
view: view_name {
  derived_analytic_model: {
    publish_as_db_analytic_model: yes | no
    model_source: explore_name {
      fields: [field_1, field_2, ...]
      join: +joined_view_name {
        foreign_key: field_name
      }
    }
  }
}

Hierarki

Lihat File

view

derived_analytic_model

Nilai Default

Tidak ada

Aturan Khusus

Model analisis hanya didukung untuk koneksi BigQuery dan Snowflake.

Definisi

Untuk koneksi BigQuery dan Snowflake, parameter derived_analytic_model menentukan model analisis dalam database (Grafik BigQuery atau tampilan semantik di Snowflake) yang dikelola oleh Looker.

Tidak seperti tabel turunan, objek model analisis yang dikelola Looker tidak menyimpan data apa pun dalam database dan tidak diperbarui secara inkremental. Sebaliknya, model ini merepresentasikan model semantik yang menentukan hubungan dan ukuran secara langsung dalam database.

Looker mendukung dua jenis model analisis turunan:

Model analisis turunan berbasis SQL: Anda menentukan model analisis menggunakan pernyataan Bahasa Definisi Data (DDL) SQL. Looker membuat model analitik dalam database Anda dengan menjalankan pernyataan SQL yang Anda tentukan.
Model analisis turunan berbasis LookML: Anda menentukan model analisis dengan mereferensikan Eksplorasi LookML yang ada. Looker secara otomatis menerjemahkan topologi, gabungan, dimensi, dan ukuran Eksplorasi Anda ke dalam pernyataan DDL model analitik native database serta membuat dan mengelola model di database Anda.

Model analisis turunan berbasis SQL

Dalam model analitik turunan berbasis SQL, Looker membuat model analitik dalam database Anda dengan menjalankan pernyataan Bahasa Definisi Data (DDL) SQL yang sesuai yang Anda tentukan dalam definisi parameter LookML derived_analytic_model. Sintaksis SQL yang Anda tentukan dalam parameter derived_analytic_model harus didukung oleh database Anda.

Untuk menentukan model analisis berbasis SQL, gunakan salah satu subparameter berikut dari parameter derived_analytic_model:

sql
sql_create
create_process

Selain itu, jika Anda menentukan tampilan analisis dengan subparameter sql, Anda dapat menggunakan subparameter publish_as_db_analytic_model dari parameter derived_analytic_model untuk membuat model analisis stabil yang dapat dikueri di luar Looker.

Setelah menentukan model analisis di dalam parameter derived_analytic_model, Anda dapat menentukan dimensi dan ukuran LookML yang dipetakan ke model analisis. Lihat bagian Contoh model analisis turunan berbasis SQL untuk mengetahui informasi selengkapnya.

`sql`

Gunakan parameter sql jika Anda ingin memberikan SQL hanya untuk definisi model analisis dan membuat Looker mengelola pembuatan model analisis. Saat Anda menggunakan subparameter sql, jangan sertakan pernyataan CREATE atau CREATE OR REPLACE, karena Looker akan otomatis membuat pernyataan DDL untuk membuat model analisis di sisi database.

Lihat Membuat model analisis turunan dengan sql untuk contoh penggunaan parameter sql guna membuat model analisis di database Anda.

`sql_create`

Gunakan parameter sql_create untuk menentukan pernyataan SQL lengkap guna membuat model analitik. Saat menggunakan parameter sql_create, Anda harus menyertakan pernyataan CREATE OR REPLACE (atau pernyataan CREATE, jika dialek Anda tidak mendukung CREATE OR REPLACE).

Perhatikan hal berikut saat Anda menggunakan subparameter sql_create:

Untuk koneksi BigQuery, gunakan pernyataan CREATE OR REPLACE untuk membuat model analisis.
Gunakan ${SQL_TABLE_NAME} untuk mengganti nama model analisis yang sedang dibuat. Hal ini memastikan bahwa pernyataan SQL akan menyertakan nama model analisis yang Anda berikan dengan benar dalam parameter view LookML.

Lihat Membuat model analisis turunan dengan sql_create untuk contoh penggunaan parameter sql_create guna membuat model analisis di database Anda.

`create_process`

Gunakan parameter create_process saat Anda perlu menentukan beberapa pernyataan SQL berurutan untuk menentukan model analisis. Di bagian parameter create_process, gunakan subparameter sql_step untuk menentukan setiap pernyataan SQL. Database Anda akan menjalankan pernyataan sql_step satu per satu, sesuai urutan yang Anda tentukan. Looker mengeluarkan pernyataan SQL dalam subparameter sql_step saat Anda menentukannya, tanpa wrapper, yang berarti Anda harus menyertakan langkah dengan pernyataan CREATE OR REPLACE (atau pernyataan CREATE, jika dialek Anda tidak mendukung CREATE OR REPLACE).

Lihat Membuat model analisis turunan dengan create_process untuk contoh penggunaan parameter create_process guna membuat model analisis di database Anda.

`publish_as_db_analytic_model`

Untuk model analisis turunan yang dibuat dengan parameter sql, Anda dapat menentukan model analisis turunan dengan publish_as_db_analytic_model: yes untuk meminta Looker membuat model analisis stabil yang dapat dikueri di luar Looker.

Model analisis yang stabil akan dipublikasikan (dibuat) pada siklus regenerator Looker berikutnya setelah LookML model analisis turunan di-deploy ke produksi dengan publish_as_db_analytic_model: yes.

Saat Anda menentukan publish_as_db_analytic_model: yes, regenerator Looker akan membuat dua model analisis di database Anda: satu dengan nama internal dan satu dengan nama stabil. Jika tidak, regenerator hanya membuat satu model analisis dalam database, menggunakan nama internal.

Lihat bagian Mengakses model analisis stabil untuk mengetahui informasi tentang cara mendapatkan nama model analisis stabil sehingga Anda dapat menggunakan nama tersebut untuk membuat kueri model analisis stabil di luar Looker.

Membuat dimensi dan ukuran LookML berdasarkan tampilan analisis berbasis SQL

Setelah menentukan model analisis, dalam file tampilan yang sama, Anda dapat menentukan dimensi dan ukuran LookML yang didasarkan pada model analisis.

Lihat dokumentasi dialek Anda untuk mengetahui informasi tentang sintaksis yang tepat untuk digunakan dalam menentukan model analisis, dan untuk merujuk elemen dalam model analisis Anda. Misalnya, untuk membuat dimensi LookML dari entitas Grafik BigQuery, Anda harus menggunakan garis bawah untuk memisahkan elemen saat menentukan cakupan. Misalnya, untuk BigQuery Graph, dimensi LookML ini didasarkan pada properti location_id dalam tabel node Stores:

  dimension: location_id {
    type: number
    sql: Stores_location_id ;;
  }

Namun, untuk membuat dimensi LookML yang didasarkan pada tampilan semantik Snowflake, Anda harus menggunakan nama metrik atau dimensi yang tidak memenuhi syarat.

Contoh model analisis turunan berbasis SQL

Bagian berikut memberikan contoh pembuatan tampilan analisis menggunakan berbagai subparameter derived_analytic_model:

Membuat model analisis turunan dengan sql
Membuat model analisis turunan dengan create_process
Membuat model analisis turunan dengan sql_create

Membuat model analisis turunan dengan `sql`

Berikut adalah contoh file tampilan LookML yang menentukan model analisis berbasis SQL untuk database BigQuery menggunakan subparameter sql dari derived_analytic_model. Looker akan membuat model analitik dalam database dengan menjalankan perintah DDL SQL yang disediakan dalam parameter sql.

Perhatikan hal berikut dalam contoh:

Subparameter sql hanya berisi definisi model analitik itu sendiri. Tidak ada pernyataan CREATE, karena dengan sql Looker secara otomatis menangani perintah CREATE untuk model analisis.
Model analisis ditentukan dengan publish_as_db_analytic_model: yes, sehingga Looker akan membuat model analisis stabil yang dapat dikueri di luar Looker.

view: MyWarehouseOrdersView {
  derived_analytic_model: {
    publish_as_db_analytic_model: yes

    # Defining the analytic model
    
    sql:
      NODE TABLES (
        Customers
        KEY(customer_id)
        PROPERTIES(
          country_code,
          concat(first_name, ' ', last_name) AS name,
          age,
          MEASURE(AVG(age)) AS AvgAge 
        ),
      Orders
        KEY(order_id)
        PROPERTIES (
          customer_id,
          employee_id,
          date,
          discount,
          MEASURE(AVG(discount)) AS AvgDiscount
        )

      EDGE TABLES (
        -- Relationship: Orders -> Customers
        looker_test.orders AS orders_to_users
          KEY(id)
          SOURCE KEY (order_id) REFERENCES orders (order_id)
          DESTINATION KEY (customer_id) REFERENCES Customers (customer_id)
          NO PROPERTIES
      ) ;;
  }

  # Mapping dimensions/measures to the dimensions/measures
  # provided by the analytic model

  dimension: customer_id {
    type: number
    sql: Customers_customer_id ;;
  }

  dimension: customer_age {
    type: number
    sql: Customers_age ;;
  }

  measure: orders_avg_discount {
    type: number
    sql: Orders_AvgDiscount ;; 
  }
}

Membuat model analisis turunan dengan `create_process`

Berikut adalah contoh file tampilan LookML yang menentukan model analisis berbasis SQL untuk database BigQuery dengan menggunakan subparameter create_process dari derived_analytic_model. Dalam contoh ini, Anda perlu menentukan beberapa pernyataan SQL berurutan untuk menentukan model analitik. Langkah pertama menghapus model analitik jika sudah ada, dan langkah kedua membuat model analitik.

view: university_statistics {
  derived_analytic_model: {
    create_process: {
      sql_step: 
        DROP PROPERTY GRAPH IF EXISTS ${SQL_TABLE_NAME} ;;
      sql_step: 
        CREATE PROPERTY GRAPH ${SQL_TABLE_NAME}
         NODE TABLES (
          university.College
            KEY(college_id)
            PROPERTIES(college_id, college_name),
          university.Department
            KEY(dept_id)
            PROPERTIES(dept_id, dept_name, college_id,
              budget OPTIONS(description="Department budget in USD"),
              MEASURE(SUM(budget)) AS total_budget),
          university.Course
            KEY(course_id)
            PROPERTIES(
              course_id,
              course_name,
              credits,
              dept_id,
              MEASURE(AVG(credits)) AS avg_credits,
              MEASURE(SUM(credits)) AS total_credits,
              MEASURE(COUNT(course_id)) AS course_count)
        )
        EDGE TABLES (
          university.Department AS CollegeDept
            SOURCE KEY (college_id) REFERENCES College (college_id)
            DESTINATION KEY (dept_id) REFERENCES Department (dept_id),
          university.Course AS DeptCourse
            SOURCE KEY (dept_id) REFERENCES Department (dept_id)
            DESTINATION KEY (course_id) REFERENCES Course (course_id)
        );;
    }
  }

  # Mapping dimensions/measures to the dimensions/measures
  # provided by the analytic model

  dimension: college_id {
    type: number
    sql: College_college_id ;;
  }

  dimension: course_name {
    type: string
    sql: Course_course_name ;;
  }
  
  ...
}

Membuat model analisis turunan dengan `sql_create`

Berikut adalah contoh file tampilan LookML yang menentukan model analisis berbasis SQL untuk database BigQuery dengan menggunakan subparameter sql_create dari derived_analytic_model. Dalam contoh ini, parameter sql_create menentukan pernyataan CREATE OR REPLACE lengkap yang akan dieksekusi untuk membuat model analitik dalam satu langkah.

view: MyWarehouseOrdersView {
  derived_analytic_model: {
    sql_create:
      CREATE OR REPLACE PROPERTY GRAPH ${SQL_TABLE_NAME}
        NODE TABLES(
          accounting.Loan AS Loan
            KEY(loanId)
            LABEL Loan PROPERTIES(
              loanId,
              loanAmount,
              balance,
              createTime,
              interestRate,
              accountId,
              balance + 100 AS derived_balance,
              CASE WHEN balance > 1000 THEN "High" ELSE "Low" END AS risk_level,
              CONCAT("ID-", CAST(loanId AS STRING)) AS full_id,
              DATE(2024, 1, 1) AS fixed_date,
              MEASURE(AVG(interestRate)) AS avg_interest_rate
            ),
          accounting.AccountView AS Account
            KEY(accountId)
            LABEL Account PROPERTIES(
              accountId,
              createTime,
              isBlocked,
              accountType,
              amount,
              ownerId,
              MEASURE(MIN(createTime)) AS oldest_account_create_time,
              MEASURE(MAX(createTime)) AS newest_account_create_time,
              MEASURE(AVG(amount)) AS avg_account_amount,
              MEASURE(SUM(amount)) AS total_account_amount,
              MEASURE(COUNT(DISTINCT accountType)) AS account_type_count
            ),
          accounting.PersonMV AS Person
            KEY(personId)
            LABEL Person PROPERTIES(
              personId,
              personName,
              age,
              age_tier,
              MEASURE(AVG(age)) AS avg_age,
              MEASURE(COUNT(DISTINCT age_tier)) AS age_tier_count
            )
        )
        EDGE TABLES(
          accounting.Loan AS Account_Repay_Loan
            KEY(loanId)
            SOURCE KEY(loanId) REFERENCES Loan(loanId)
            DESTINATION KEY(accountId) REFERENCES Account(accountId)
            LABEL Repay NO PROPERTIES,
          accounting.Account AS Person_Own_Account
            KEY(accountId)
            SOURCE KEY(accountId) REFERENCES Account(accountId)
            DESTINATION KEY(ownerId) REFERENCES Person(personId)
            LABEL Own NO PROPERTIES
        );;
  }

  # Mapping dimensions/measures to the dimensions/measures
  # provided by the analytic model

  dimension: loan_id {
    type: number
    sql: Loan_loanId ;;
  }

  dimension: account_ID {
    type: number
    sql: Account_accountID ;;
  }

  ...

}

Mengakses model analisis stabil

Jika Anda membuat model analisis turunan menggunakan subparameter sql dan menyertakan pernyataan publish_as_db_analytic_model: yes di bawah parameter derived_analytic_model, Looker akan memublikasikan (membuat) model analisis stabil pada siklus regenerator Looker berikutnya setelah LookML model analisis turunan di-deploy ke produksi dengan publish_as_db_analytic_model: yes.

Saat model analisis stabil dipublikasikan, Anda dapat membuat kueri secara langsung menggunakan nama stabilnya. Ada dua cara untuk mendapatkan nama stabil model analisis:

Modal detail PDT
Tab SQL pada Eksplorasi

Modal detail PDT

Jika Anda adalah admin atau pengguna dengan izin see_pdts, Anda dapat mengikuti langkah-langkah berikut untuk menggunakan halaman Persistent Derived Tables di bagian Admin Looker guna mendapatkan nama model analisis yang stabil untuk model analisis:

Klik ikon Menu utama Looker , lalu pilih Admin, jika menu Admin belum ditampilkan. (Jika Anda berada di bagian Jelajahi atau Kembangkan di Menu utama Looker, Anda mungkin harus mengklik panah kembali untuk melihat menu Admin.)
Dari menu Admin, pilih Persistent Derived Tables.
Di halaman Persistent Derived Tables, telusuri nama model analisis Anda.
Klik menu tiga titik untuk model analisis Anda, lalu pilih Detail PDT.
Di PDT Details modal, cari kolom Stable Name.

Untuk membuat kueri model analitik stabil secara langsung, tambahkan nama skema sementara sebelum nama model. Misalnya, jika nama skema sementara adalah tmp, Anda dapat mengkueri model analitik yang stabil dengan perintah seperti ini:

SELECT * from tmp.PA_bq_analytic_model_sales_semantic_view

Tab SQL pada Eksplorasi

Jika tidak memiliki akses ke halaman admin Persistent Derived Tables, Anda dapat menentukan nama stabil dari informasi yang disertakan di tab SQL di bagian Data pada kueri Eksplorasi model analisis. Ikuti langkah-langkah berikut untuk mendapatkan nama stabil model analisis:

Buka Jelajahi untuk tampilan model analisis Anda.

Tips: Jika Anda berada di Looker IDE, Anda dapat menggunakan menu drop-down Lihat tindakan file untuk membuka Eksplorasi langsung dari file tampilan model analisis atau dari file model yang menentukan Eksplorasi untuk tampilan model analisis.
Di Eksplorasi, pilih dimensi atau ukuran apa pun dari pemilih kolom.
Klik tab SQL di bagian Data.
Di tab SQL, temukan salah satu pernyataan SQL berikut:
- Untuk Grafik BigQuery:
  - CREATE PROPERTY GRAPH
  - SELECT ... FROM GRAPH_EXPAND('PROPERTY_GRAPH_NAME')
- Untuk tampilan semantik Snowflake:
  - CREATE SEMANTIC VIEW
  - SELECT ... FROM SEMANTIC_VIEW_NAME
Nama stabil adalah tampilan yang dibuat Looker dalam skema sementara, yang mengarah ke tabel sebenarnya yang di-obfuscate dan ditampilkan di tab SQL. Untuk mendapatkan nama stabil untuk tampilan analisis, isi informasi berikut dari pernyataan SQL:
```
SCRATCH_SCHEMA_NAME.CONNECTION_REGISTRATION_KEY_MODEL_NAME_VIEW_NAME
```
- SCRATCH_SCHEMA_NAME: Nama skema sementara adalah awal string setelah pernyataan CREATE atau SELECT, sebelum "."
- CONNECTION_REGISTRATION_KEY: Kunci pendaftaran koneksi terdiri dari dua karakter; bergantung pada dialek database Anda, kunci ini akan mengikuti tanda dolar atau garis bawah pertama dalam nama tabel di pernyataan CREATE atau SELECT.
- MODEL_NAME: Nama model LookML.
- VIEW_NAME: Nama tampilan tempat model analisis ditentukan.

Misalnya, berikut adalah teks dari tab SQL kueri Jelajah untuk koneksi BigQuery. Model analisis ditentukan dalam tampilan yang bernama sales_analytic_model, dan nama model LookML adalah thelook. Dalam hal ini, Looker telah membuat model analisis, sehingga tidak ada pernyataan CREATE. Namun, pernyataan SELECT ... FROM GRAPH_EXPAND berisi informasi nama tabel:

-- use existing sales_analytic_model in `looker-test-db.looker_scratch.LG_J7LSZ1778710001008_sales_analytic_model`
SELECT
    sales_analytic_model.orders_id  AS sales_analytic_model_orders_id,
    AGG(sales_analytic_model.orders_count_orders ) AS sales_analytic_model_count_orders
FROM GRAPH_EXPAND("looker-test-db.looker_scratch.LG_J7LSZ1778710001008_sales_analytic_model") AS sales_analytic_model
GROUP BY
    1
ORDER BY
    2 DESC
LIMIT 500

Berikut adalah nilai yang Anda perlukan untuk mendapatkan nama stabil model analisis:

SCRATCH_SCHEMA_NAME looker-test-db.looker_scratch
CONNECTION_REGISTRATION_KEY J7
MODEL_NAME thelook
VIEW_NAME sales_analytic_model

Oleh karena itu, nama stabil untuk model analisis adalah sebagai berikut:

looker-test-db.looker_scratch.J7_thelook_sales_analytic_model

Setelah memiliki nama stabil model analisis, Anda dapat membuat kueri model analisis secara langsung.

Model analisis turunan berbasis LookML

Model analisis turunan berbasis LookML memungkinkan Anda menentukan model analisis dalam database (seperti BigQuery Graph atau tampilan semantik Snowflake) langsung dari Eksplorasi LookML yang ada tanpa perlu menulis pernyataan DDL SQL khusus database.

Gunakan parameter berikut untuk menentukan model analisis turunan berbasis LookML:

model_source
- fields (subparameter dari model_source)
- join (subparameter model_source; gabung sendiri memiliki subparameter)
publish_as_db_analytic_model (parameter ini berlaku untuk model analitik turunan berbasis LookML dan berbasis SQL)

Untuk membuat model analitik turunan berbasis LookML, Anda menggunakan parameter model_source untuk mengarah ke Eksplorasi sumber yang menentukan topologi data Anda. Kemudian, Looker akan otomatis menerjemahkan tampilan, gabungan, dimensi, dan ukuran LookML Anda ke dalam pernyataan DDL model analitik native database:

Node / Tabel: Setiap tampilan LookML di Eksplorasi sumber menjadi tabel node di BigQuery Graph atau tabel dalam tampilan semantik Snowflake.
Edge / Hubungan: Setiap gabungan yang ditentukan dengan parameter foreign_key di Eksplorasi sumber menjadi tabel edge di BigQuery Graph atau hubungan dalam tampilan semantik Snowflake.
Properti / Dimensi dan Metrik: Dimensi dan ukuran LookML dari tampilan sumber menjadi properti node di BigQuery Graph atau dimensi dan metrik dalam tampilan semantik Snowflake.

Saat Anda mengkueri Eksplorasi yang didasarkan pada tampilan model analitik turunan berbasis LookML, Looker akan membuat dan menjalankan DDL database untuk membuat model analitik dalam skema sementara database Anda, lalu menjalankan kueri terhadap model analitik yang dibuat. Setelah model analisis dibuat, Looker akan mempertahankannya sehingga kueri berikutnya langsung mereferensikan model yang ada hingga definisi LookML-nya diubah.

`model_source`

Parameter model_source menentukan nama Eksplorasi LookML yang berfungsi sebagai sumber topologi dan hubungan untuk model analisis.

view: sales_analytic_model {
  derived_analytic_model: {
    model_source: order_items {
      fields: [order_items.id, orders.id, orders.status, users.name]
    }
  }
}

Tampilan yang disertakan dalam Jelajah sumber harus memiliki kunci utama yang ditentukan dengan menggunakan primary_key: yes pada dimensi kunci utamanya.

model_source menerima subparameter berikut:

Parameter	Deskripsi
`fields`	Opsional. Menentukan daftar yang diizinkan atau daftar yang tidak diizinkan dari kolom dari Jelajah sumber untuk diekspor ke model analisis.
`join` (atau `joins`)	Opsional. Menentukan atau menyempurnakan gabungan dari Eksplorasi sumber secara khusus untuk model analisis.

`fields`

Secara default, semua kolom yang tersedia dari tampilan di Eksplorasi sumber diekspor ke model analisis (beberapa kolom dari Eksplorasi sumber mungkin tidak tersedia jika Eksplorasi sumber itu sendiri ditentukan dengan parameter fields). Anda dapat menggunakan subparameter fields di dalam model_source untuk menentukan subset kolom yang akan diekspor, atau untuk mengecualikan kolom tertentu menggunakan sintaksis daftar LookML standar:

  view: sales_analytic_model {
    derived_analytic_model: {
      model_source: order_items {
        fields: [
          order_items.id,
          order_items.price,
          orders.id,
          orders.status,
          users.name
        ]
      }
    }
  }

`join`

Parameter join di dalam model_source memungkinkan Anda menambahkan penyempurnaan pada gabungan yang sudah ditentukan dalam Jelajah sumber. Dengan menambahkan penyempurnaan, Anda dapat melakukan penyesuaian yang dicakup secara eksklusif ke model analitik tanpa mengubah definisi Eksplorasi sumber.

Di parameter join di bagian model_source, tentukan nama gabungan dari Jelajah sumber dengan indikator penyesuaian +. Contoh, join: +view_name. Kemudian, gunakan subparameter join untuk menyempurnakan gabungan dari Eksplorasi sumber sesuai kebutuhan dalam model analisis Anda. Lihat langkah 2 untuk melihat contoh.

Parameter join dalam model_source hanya menggunakan penyempurnaan gabungan. Anda tidak dapat menambahkan gabungan baru ke model analisis yang belum ada di Jelajah sumber.

Parameter join dalam model_source mendukung subparameter berikut:

Subparameter	Deskripsi
`foreign_key`	Menentukan kolom atau dimensi kunci asing yang menetapkan hubungan untuk model analisis. Untuk contoh dengan parameter `foreign_key`, lihat contoh di langkah 1.
`relationship`	Menentukan kardinalitas gabungan (`many_to_one`, `one_to_one`, `one_to_many`, atau `many_to_many`).

Menyiapkan model analisis turunan berbasis LookML

Untuk menyiapkan model analisis turunan berbasis LookML, ikuti langkah-langkah berikut:

Menentukan tampilan dasar dan Jelajah sumber dengan gabungan foreign_key
Membuat tampilan model analisis turunan
Menentukan dimensi dan ukuran LookML dalam tampilan model analisis
Membuat Eksplorasi untuk tampilan model analisis
Mengirim kueri ke model analisis di Looker

Langkah 1: Tentukan tampilan dasar dan Eksplorasi sumber dengan gabungan `foreign_key`

Pertama, pastikan tampilan dasar Anda (seperti order_items, orders, dan users) ditentukan dengan kunci utama.

Selanjutnya, tentukan Eksplorasi dalam file model LookML yang menentukan hubungan antar-tampilan. Membangun hubungan dalam model analisis dalam database secara ketat memerlukan parameter foreign_key pada setiap gabungan di Jelajah sumber:

explore: order_items {
  fields: [ALL_FIELDS*]

  join: orders {
    relationship: many_to_one
    foreign_key: order_id
  }

  join: users {
    relationship: many_to_one
    foreign_key: orders.user_id
  }
}

Langkah 2: Buat tampilan model analisis turunan

Buat file tampilan baru (misalnya, sales_analytic_model.view.lkml) dan tambahkan blok derived_analytic_model dengan parameter model_source yang mengarah ke Eksplorasi sumber Anda:

view: sales_analytic_model {
  derived_analytic_model: {
    model_source: order_items {
      # Optional: Use fields to restrict the properties exported to the analytic model
      # fields: [order_items.id, orders.id, orders.status, users.name]

      # Optional: Use join refinements to refine the relationships from the source Explore
      # join: +orders {
      #   foreign_key: order_id
      # }
      # join: +users {
      #   foreign_key: orders.user_id
      # }
    }
  }
  ...

Langkah 3: Tentukan dimensi dan ukuran LookML di tampilan model analisis

Dalam file tampilan model analisis yang sama, tentukan dimensi, grup dimensi, dan ukuran yang dipetakan ke properti dalam model analisis yang dihasilkan sehingga dapat dikueri di Eksplorasi Looker.

Merujuk kolom dari model pokok menggunakan ${TABLE}.<view_name>_<field_name> (atau ${TABLE}.<property_name>):

  # Dimensions
  dimension: order_items_id {
    type: number
    sql: ${TABLE}.order_items_id ;;
  }

  dimension: orders_id {
    type: number
    sql: ${TABLE}.orders_id ;;
  }

  dimension: orders_status {
    type: string
    sql: ${TABLE}.orders_status ;;
  }

  dimension_group: orders_created {
    type: time
    timeframes: [raw, time, date, week, month, quarter, year]
    sql: ${TABLE}.orders_created_at ;;
  }

  dimension: users_name {
    type: string
    sql: ${TABLE}.users_name ;;
  }

  dimension_group: users_created {
    type: time
    timeframes: [raw, time, date, week, month, quarter, year]
    sql: ${TABLE}.users_created_at ;;
  }

  # Measures
  measure: count_users {
    type: number
    sql: ${TABLE}.users_count_users ;;
  }

  measure: count_orders {
    type: number
    sql: ${TABLE}.orders_count_orders ;;
  }

  measure: total_order_amount {
    type: number
    sql: ${TABLE}.orders_total_order_amount ;;
  }

  measure: total_order_item_amount {
    type: number
    sql: ${TABLE}.order_items_total_order_item_amount ;;
  }
}

Langkah 4: Buat Eksplorasi untuk tampilan model analisis

Dalam file model (seperti sales.model.lkml), buat Jelajah untuk tampilan model analisis menggunakan nama tampilan:

explore: sales_analytic_model {}

Eksplorasi yang didasarkan pada tampilan model analisis tidak dapat berisi gabungan, karena hubungan ditentukan secara internal dalam model analisis itu sendiri.

Langkah 5: Kueri model analisis di Looker

Buka Eksplorasi baru (misalnya, Model Analisis Penjualan) di Looker, pilih dimensi dan ukuran, lalu jalankan kueri Anda.

Untuk memeriksa SQL yang dihasilkan, ikuti langkah-langkah berikut:

Klik tab SQL di panel Data.
Di tab SQL, Anda dapat melihat pernyataan DDL khusus database yang dibuat Looker (seperti CREATE PROPERTY GRAPH ... dengan NODE TABLES dan EDGE TABLES untuk BigQuery Graph) dan kueri yang dijalankan terhadap model analitik (seperti FROM GRAPH_EXPAND(...) AS sales_analytic_model).
Saat kueri dijalankan, Looker akan mempertahankan model analisis dalam skema sementara database. Kueri berikutnya menggunakan kembali model yang dipertahankan, sehingga menghindari eksekusi ulang DDL hingga definisi LookML berubah.

Pertimbangan untuk model analisis turunan berbasis LookML

Saat menentukan model analisis turunan berbasis LookML, perhatikan pertimbangan berikut:

Kunci utama: Setiap tampilan di Eksplorasi sumber harus memiliki dimensi kunci utama yang ditentukan dengan menggunakan primary_key: yes.
Topologi asiklik: Hubungan yang ditentukan oleh gabungan dalam Eksplorasi sumber harus membentuk struktur pohon asiklik yang ketat. Hubungan siklik tidak didukung.
Persyaratan tampilan sumber: Tampilan yang disertakan dalam Jelajah sumber harus berupa tabel database standar atau tabel turunan persisten (PDT) dengan nama yang stabil. Tabel dan tampilan turunan sementara (tidak persisten) yang didasarkan pada model analisis lain tidak dapat digunakan sebagai sumber.
Parameter eksplorasi: Parameter pemfilteran runtime dinamis (sql_always_where, always_filter, access_filter) dan sql_always_join di Eksplorasi sumber diabaikan selama pembuatan model analisis.

Hal-hal yang perlu dipertimbangkan

Saat menggunakan model analisis dalam database, perhatikan pertimbangan dan batasan berikut:

Jenis data: Hanya jenis data berikut untuk dimensi dan metrik yang didukung dengan model analisis:
- Didukung untuk dimensi dan ukuran:
  - string
  - number
  - date
  - yesno
- Hanya didukung untuk dimensi:
  - time
  - date_time
Ukuran:
- Ukuran dasar harus ditentukan sebelumnya: Ukuran dasar harus ditentukan sebelumnya dalam model analitik database yang mendasarinya. Looker tidak dapat menentukan ukuran dasar baru dengan melakukan agregasi (seperti type: sum atau type: count) pada dimensi dari model analisis.
- Ukuran yang didasarkan pada ukuran lain didukung: Anda dapat menggunakan parameter sql dari ukuran LookML untuk melakukan komputasi non-gabungan yang menggunakan ukuran dasar yang telah ditentukan sebelumnya dari model analisis. Saat membuat ukuran yang didasarkan pada ukuran lain, Anda tidak dapat menentukan ukuran baru sebagai jenis ukuran agregat seperti sum atau count. Anda harus menentukan ukuran baru sebagai jenis ukuran non-gabungan, seperti string, number, date, atau yesno. Lihat contoh berikut:
```
measure: average_order_amount {
  type: number
  sql: ROUND(${total_order_amount} / NULLIF(${count_orders}, 0), 2) ;;
}
```
Gabungan: Eksplorasi yang tampilan dasarnya didasarkan pada model analitik tidak dapat menyertakan gabungan apa pun. Demikian pula, tampilan yang didasarkan pada model analisis tidak dapat digabungkan ke dalam Eksplorasi yang memiliki tampilan dasar LookML standar.
Penggabungan implisit: Fitur yang mengandalkan penggabungan implisit tidak didukung untuk model analitik. Beberapa contoh fitur yang mengandalkan gabungan implisit adalah kalender kustom dan kolom yang ditentukan dengan type: location, type: distance, atau type: zipcode.
Fitur berikut tidak didukung dengan model analisis: