derived_analytic_model

Penggunaan

view: view_name {
  derived_analytic_model: {
    sql: analytic_model_definition ;;
  }
}
Hierarki
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. Dalam skenario ini, 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.

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.

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

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 untuk melihat contoh.

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 LookML view.

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.

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 Anda

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 ke elemen dalam model analisis. Misalnya, untuk membuat dimensi LookML dari entitas Grafik BigQuery, Anda harus menggunakan garis bawah untuk memisahkan elemen saat menentukan cakupan. Misalnya, untuk Grafik BigQuery, 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

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

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 analisis 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 analitik 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. Anda dapat menentukan nama stabil dari informasi yang disertakan di tab SQL di bagian Data pada kueri Jelajah model analisis. Ikuti langkah-langkah berikut untuk mendapatkan nama stabil model analisis:

  1. Buka Jelajahi untuk tampilan model analisis Anda.

  2. Di Eksplorasi, pilih dimensi atau ukuran apa pun dari pemilih kolom.

  3. Klik tab SQL di bagian Data.

  4. 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

  5. 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.

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: