2026년 Looker와 LookML 완벽 가이드: 비즈니스 인텔리전스 및 면접 대비

# views/orders.view.lkml
view: orders {
  sql_table_name: `analytics.orders` ;;

  dimension: order_id {
    primary_key: yes
    type: number
    sql: ${TABLE}.order_id ;;
  }

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

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

  measure: total_orders {
    type: count
    drill_fields: [order_id, created_date, status]
  }

  measure: total_revenue {
    type: sum
    sql: ${TABLE}.amount ;;
    value_format_name: usd
  }
}

# models/ecommerce.model.lkml
explore: orders {
  label: "주문 분석"
  description: "주문, 고객, 상품 데이터를 결합한 분석용 Explore"

  join: customers {
    type: left_outer
    relationship: many_to_one
    sql_on: ${orders.customer_id} = ${customers.customer_id} ;;
  }

  join: products {
    type: left_outer
    relationship: many_to_one
    sql_on: ${orders.product_id} = ${products.product_id} ;;
  }

  join: order_items {
    type: left_outer
    relationship: one_to_many
    sql_on: ${orders.order_id} = ${order_items.order_id} ;;
  }
}

-- Looker가 생성하는 대칭 집계 SQL
SELECT
  SUM(DISTINCT CONCAT(
    CAST(orders.order_id AS STRING),
    '|',
    CAST(orders.amount AS STRING)
  )) AS total_revenue
FROM orders
JOIN order_items ON orders.order_id = order_items.order_id

view: daily_order_summary {
  derived_table: {
    sql:
      SELECT
        DATE(created_at) AS order_date,
        COUNT(*) AS order_count,
        SUM(amount) AS daily_revenue
      FROM orders
      GROUP BY 1
    ;;

    datagroup_trigger: orders_datagroup
    indexes: ["order_date"]
  }

  dimension: order_date {
    type: date
    sql: ${TABLE}.order_date ;;
  }

  measure: total_order_count {
    type: sum
    sql: ${TABLE}.order_count ;;
  }

  measure: total_daily_revenue {
    type: sum
    sql: ${TABLE}.daily_revenue ;;
  }
}

view: customer_lifetime_value {
  derived_table: {
    explore_source: orders {
      column: customer_id { field: customers.customer_id }
      column: total_orders { field: orders.total_orders }
      column: total_revenue { field: orders.total_revenue }
      column: first_order_date { field: orders.created_date }
      column: last_order_date { field: orders.created_date }

      derived_column: customer_tenure_days {
        sql: DATE_DIFF(last_order_date, first_order_date, DAY) ;;
      }
    }

    datagroup_trigger: orders_datagroup
  }

  dimension: customer_id {
    primary_key: yes
    type: number
  }

  dimension: customer_segment {
    type: string
    sql:
      CASE
        WHEN ${total_revenue} >= 10000 THEN 'VIP'
        WHEN ${total_revenue} >= 1000 THEN 'Active'
        ELSE 'Standard'
      END
    ;;
  }
}

view: orders {
  parameter: date_granularity {
    type: unquoted
    allowed_values: ["day", "week", "month", "quarter", "year"]
    default_value: "month"
  }

  dimension: dynamic_date {
    type: string
    sql:
      {% if date_granularity._parameter_value == 'day' %}
        DATE(${created_raw})
      {% elsif date_granularity._parameter_value == 'week' %}
        DATE_TRUNC(${created_raw}, WEEK)
      {% elsif date_granularity._parameter_value == 'month' %}
        DATE_TRUNC(${created_raw}, MONTH)
      {% elsif date_granularity._parameter_value == 'quarter' %}
        DATE_TRUNC(${created_raw}, QUARTER)
      {% else %}
        DATE_TRUNC(${created_raw}, YEAR)
      {% endif %}
    ;;
  }

  measure: filtered_revenue {
    type: sum
    sql: ${TABLE}.amount ;;
    filters: [status: "completed, shipped"]
  }
}

explore: orders {
  access_filter: {
    field: orders.region
    user_attribute: allowed_regions
  }

  access_filter: {
    field: customers.customer_segment
    user_attribute: visible_segments
  }
}

datagroup: orders_datagroup {
  max_cache_age: "24 hours"
  sql_trigger: SELECT MAX(updated_at) FROM orders ;;
}

datagroup: realtime_datagroup {
  max_cache_age: "5 minutes"
  sql_trigger: SELECT CURRENT_TIMESTAMP() ;;
}

explore: orders {
  persist_with: orders_datagroup
}

explore: realtime_metrics {
  persist_with: realtime_datagroup
}

explore: orders {
  aggregate_table: daily_orders_rollup {
    query: {
      dimensions: [created_date, status, region]
      measures: [total_orders, total_revenue]
    }

    materialization: {
      datagroup_trigger: orders_datagroup
    }
  }

  aggregate_table: monthly_orders_rollup {
    query: {
      dimensions: [created_month, status]
      measures: [total_orders, total_revenue, average_order_value]
    }

    materialization: {
      datagroup_trigger: orders_datagroup
    }
  }
}

view: incremental_orders {
  derived_table: {
    sql:
      SELECT *
      FROM orders
      WHERE created_at >= COALESCE(
        (SELECT MAX(created_at) FROM ${SQL_TABLE_NAME}),
        '1900-01-01'
      )
    ;;

    datagroup_trigger: hourly_datagroup
    increment_key: "created_at"
    increment_offset: 3
  }
}

import looker_sdk

sdk = looker_sdk.init40()

# 대시보드를 프로그래밍 방식으로 실행
result = sdk.run_look(
    look_id=123,
    result_format="json"
)

# 스케줄을 동적으로 생성
schedule = sdk.create_scheduled_plan(
    body={
        "name": "Daily Revenue Report",
        "look_id": 123,
        "crontab": "0 9 * * *",
        "scheduled_plan_destination": [{
            "type": "email",
            "address": "analytics@company.com",
            "format": "csv"
        }]
    }
)

# 모델 검증 자동화
validation = sdk.validate_project(
    project_id="my_project"
)

if validation.errors:
    for error in validation.errors:
        print(f"Error in {error.file_path}: {error.message}")

models/
├── ecommerce.model.lkml
├── marketing.model.lkml
└── finance.model.lkml

views/
├── core/
│   ├── orders.view.lkml
│   ├── customers.view.lkml
│   └── products.view.lkml
├── derived/
│   ├── customer_ltv.view.lkml
│   └── daily_metrics.view.lkml
└── extensions/
    └── order_extended.view.lkml

datagroups/
└── datagroups.lkml