Einführung in LookML

LookML, die Kurzform von Looker Modeling Language, ist die Sprache, mit der in Looker semantische Datenmodelle erstellt werden. Sie können LookML verwenden, um Dimensionen, Aggregatfunktionen, Berechnungen und Datenbeziehungen in Ihrer SQL-Datenbank zu beschreiben. Looker verwendet ein in LookML geschriebenes Modell, um SQL-Abfragen für eine bestimmte Datenbank zu erstellen.

LookML ist eine Abhängigkeitssprache wie make, im Gegensatz zu einer imperativen Sprache wie C oder Ruby. LookML stellt vordefinierte Datentypen und Syntax für die Datenmodellierung bereit. Für das Verständnis von LookML sind keine Vorkenntnisse in Programmiersprachen erforderlich. LookML ist von bestimmten SQL-Dialekten unabhängig und enthält alle wesentlichen SQL-Ausdrücke für jede SQL-Implementierung.

Für Datenanalysten fördert LookML den DRY-Stil („Don’t wiederholen“), d. h. Sie schreiben SQL-Ausdrücke einmal an einem Ort und Looker verwendet den Code wiederholt, um Ad-hoc-SQL-Abfragen zu generieren. Geschäftsnutzer können dann mit den Ergebnissen komplexe Abfragen in Looker erstellen und sich dabei nur auf den tatsächlich benötigten Inhalt konzentrieren, nicht auf die Komplexität der SQL-Struktur.

LookML-Projekte

LookML wird in Projekten definiert. Ein LookML-Projekt ist eine Sammlung von Dateien, die mindestens Modell- und Ansichtsdateien und optional andere Dateitypen umfassen, die in der Regel zusammen über ein Git-Repository versioniert werden. Die Modelldateien enthalten Informationen dazu, welche Tabellen im Projekt verwendet werden und wie sie verknüpft werden sollen. In den Ansichtsdateien wird beschrieben, wie Informationen für jede Tabelle (oder für mehrere Tabellen, wenn die Joins dies zulassen) berechnet werden.

LookML trennt Struktur von Inhalt. Das heißt, die Abfragestruktur (wie Tabellen verbunden sind) ist vom Abfrageinhalt unabhängig (aufzurufende Spalten, abgeleitete Felder, zu berechnende Summenfunktionen und anzuwendende Filterausdrücke).

Looker-Abfragen basieren auf LookML-Projektdateien. Datenanalysten verwenden LookML, um Datenmodelle zu erstellen und zu verwalten, die die Datenstruktur und Geschäftsregeln für die zu analysierenden Daten definieren. Der Looker SQL-Generator übersetzt LookML in SQL, sodass Geschäftsnutzer Abfragen ausführen können, ohne LookML oder SQL zu schreiben.

Geschäftsnutzer verwenden den Looker-Abfragebaustein oder die Explore-Oberfläche, um Abfragen zu erstellen, die auf dem Datenmodell basieren, das Looker-Analysten definieren. Nutzer können Dimensionen, Messwerte und Filter auswählen, um benutzerdefinierte Abfragen zu erstellen, die auf ihren eigenen Fragen basieren, und um eigene Statistiken zu generieren.

Wenn ein Benutzer eine Abfrage erstellt, wird diese an den SQL-Generator von Looker gesendet, der die Abfrage in SQL übersetzt. Die SQL-Abfrage wird in der Datenbank ausgeführt und Looker gibt die formatierten Ergebnisse dann auf der Explore-Benutzeroberfläche an den Nutzer zurück. Die Nutzenden können dann die Ergebnisse visualisieren und Erkenntnisse generieren.

Weitere Informationen zu den grundlegenden LookML-Elementen in einem Projekt und ihrer Beziehung zueinander finden Sie unter LookML – Begriffe und Konzepte.

Was Nutzer sehen

Die Konfiguration des Projekts und der Inhalt der Dateien bestimmen, was Nutzer sehen und wie sie mit Looker interagieren können.

  1. Der Bereich „Erkunden“ im linken Navigationsbereich ist nach Modellnamen organisiert. Unter dem jeweiligen Modellnamen befindet sich eine Liste der in diesem Modell verfügbaren Explores.
  2. Benutzer können nach einem bestimmten Explore suchen.

  3. Entwickler können Beschreibungen für Explores definieren. Nutzer können sich diese Beschreibungen ansehen, indem sie im Menü Explore den Mauszeiger auf den Namen des Explores bewegen.

  4. Der Bereich Field Picker ist nach Ansichtsnamen organisiert. Unter jedem Ansichtsnamen befindet sich eine Liste der verfügbaren Felder aus den Tabellen in dieser Ansicht. In den meisten Ansichten werden sowohl Dimensionen als auch Messwerte angezeigt. In diesem Beispiel wird eine Dimension Monat aus einer Dimensionsgruppe Zurückgegebenes Datum ausgewählt, die in der Ansichtsdatei definiert wurde.

  5. Nutzer können mehrere Messwerte auswählen, auf denen die Abfrage basieren soll.

  6. Nutzer können im Bereich „Feldauswahl“ Optionen wie Filter und Pivot-Tabellen anwenden.

  7. Nutzer können die Begriffe der Suchanfrage verfeinern.

  8. Nutzer können einen Visualisierungstyp auswählen, der auf die Abfrageergebnisse angewendet werden soll.

  9. Wenn Sie diese explorative Datenanalyse ausführen, wird eine SQL-Abfrage generiert, die sowohl eine Datentabelle als auch eine Visualisierung des Gesamtverkaufspreises und der Bruttomarge der zurückgegebenen Bestellungen aus dem letzten Jahr zurückgibt.

Codebeispiel

Das folgende Codebeispiel zeigt ein minimales LookML-Projekt für einen E-Commerce-Shop mit einer Modelldatei (ecommercestore.model.lkml) und zwei Ansichtsdateien (orders.view.lkml und customers.view.lkml):

######################################
# FILE: ecommercestore.model.lkml    #
# Define the explores and join logic #
######################################
connection: order_database
include: "*.view.lkml"
explore: orders {
  join: customers {
    sql_on: ${orders.customer_id} = ${customers.id} ;;
  }
}

##########################################################
# FILE: orders.view.lkml                                 #
# Define the dimensions and measures for the ORDERS view #
##########################################################
view: orders {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: customer_id {      # field: orders.customer_id
    sql: ${TABLE}.customer_id ;;
  }
  dimension: amount {           # field: orders.amount
    type: number
    value_format: "0.00"
    sql: ${TABLE}.amount ;;
  }
  dimension_group: created {                # generates fields:
    type: time                              # orders.created_time, orders.created_date
    timeframes: [time, date, week, month]   # orders.created_week, orders.created_month
    sql: ${TABLE}.created_at ;;
  }
  measure: count {             # field: orders.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # list of fields to show when someone clicks 'ORDERS Count'
  }
  measure: total_amount {
    type: sum
    sql: ${amount} ;;
  }
  set: drill_set {
    fields: [id, created_time, customers.name, amount]
  }
}

#############################################################
# FILE: customers.view.lkml                                 #
# Define the dimensions and measures for the CUSTOMERS view #
#############################################################
view: customers {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: city {                    # field: customers.city
    sql: ${TABLE}.city ;;
  }
  dimension: state {                   # field: customers.state
    sql: ${TABLE}.state ;;
  }
  dimension: name {
    sql: CONCAT(${TABLE}.firstname, " ", ${TABLE}.lastname) ;;
  }
  measure: count {             # field: customers.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # fields to show when someone clicks 'CUSTOMERS Count'
  }
  set: drill_set {                     # set: customers.drill_set
    fields: [id, state, orders.count]  # list of fields to show when someone clicks 'CUSTOMERS Count'
  }
}

Weitere Informationen

Wenn Sie noch nicht mit der LookML-Entwicklung vertraut sind, können Sie die in den folgenden Abschnitten beschriebenen Ressourcen nutzen, um Ihr Lernen zu beschleunigen:

Zugriff auf die Lernumgebung von Looker erhalten

Sehen Sie sich die Kurse auf Google Cloud Skills Boost an.

Erfahren Sie, wie Sie Daten mit Looker abfragen und untersuchen können

Kenntnisse über die Datenanalyse in Looker erleichtern Ihnen die Modellierung von Daten in LookML. Wenn Sie mit der Verwendung von Looker zum Abfragen, Filtern und Aufschlüsseln von Daten nicht vertraut sind, empfehlen wir die folgenden Ressourcen:

Erforderliche SQL-Grundlagen für die Verwendung von LookML

Für die Erstellung von LookML-Codes benötigen Sie Kenntnisse in der Erstellung und Durchführung von SQL-Abfragen. Sie müssen kein SQL-Experte sein und selbst Anfänger können leistungsstarke Looker-Modelle erstellen. Im Allgemeinen gilt: Je besser Ihre SQL-Kenntnisse sind, desto einfacher wird Ihnen die Arbeit in LookML fallen.

Konsultieren Sie einige unserer bevorzugten Ressourcen, wenn Sie Ihre SQL-Kenntnisse auffrischen möchten:

LookML-Grundlagen erlernen

Diese Ressourcen ermöglichen Ihnen einen direkten Einstieg in LookML. Nutzen Sie Ihr Lernkonto, um mit verschiedenen Entwurfsmustern zu experimentieren.

Nachdem Sie die Grundlagen von LookML kennengelernt haben, finden Sie auf den folgenden Seiten eine Übersicht über die verschiedenen Arten von LookML-Parametern: