Einführung in LookML

LookML, kurz für Looker Modeling Language, ist die Sprache, die in Looker zum Erstellen semantischer Datenmodelle verwendet wird. Mit LookML lassen sich Dimensionen beschreiben, Daten aggregieren, Berechnungen durchführen und Datenbeziehungen in einer SQL-Datenbank definieren. 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. Sie benötigen keine Programmierkenntnisse, um LookML zu verstehen. LookML ist von bestimmten SQL-Dialekten unabhängig und enthält alle wesentlichen SQL-Ausdrücke für jede SQL-Implementierung.

Zugunsten von Datenanalysten fördert LookML den so genannten DRY-Stil („Don't repeat yourself“). Das heißt, Sie schreiben SQL-Ausdrücke einmal, an einem Ort und Looker verwendet diesen Code wiederholt, um Ad-hoc-SQL-Abfragen zu generieren. Geschäftliche Nutzer können die Ergebnisse dann verwenden, um komplexe Abfragen in Looker zu erstellen und sich dabei nur auf den tatsächlich benötigten Inhalt zu konzentrieren, nicht auf die Komplexität der SQL-Struktur.

LookML-Projekte

LookML wird in Projekten definiert. Ein LookML-Projekt ist eine Sammlung von Dateien, darunter mindestens Modell- und Ansichtsdateien und optional andere Dateitypen, die in der Regel gemeinsam über ein Git-Repository versioniert werden. Die Modelldateien enthalten Informationen darüber, welche Tabellen im Projekt verwendet werden und wie die Tabellen verknüpft werden sollen. Die Ansichtsdateien beschreiben, wie Informationen zu den einzelnen Tabellen (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äftliche Nutzer Abfragen ausführen können, ohne LookML oder SQL schreiben zu müssen.

Geschäftliche Nutzer verwenden den Looker-Abfrage-Editor oder die Explore-Oberfläche, um Abfragen zu erstellen, die auf dem Datenmodell basieren, das von Looker-Analysten definiert wurde. Nutzer können Dimensionen, Messwerte und Filter auswählen, um benutzerdefinierte Abfragen zu erstellen, die auf ihren eigenen Fragen basieren, und um eigene Erkenntnisse zu gewinnen.

Wenn ein Nutzer eine Abfrage erstellt, wird sie an den Looker-SQL-Generator 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-Oberfläche an den Nutzer zurück. Der Nutzer kann die Ergebnisse dann visualisieren und Erkenntnisse gewinnen.

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

Was Nutzer sehen

Wie das Projekt eingerichtet ist und welche Inhalte in den Dateien enthalten sind, bestimmt, was Nutzer sehen und wie sie mit Looker interagieren können.

  1. Der Bereich „Explore“ im linken Navigationsbereich ist nach Modellnamen strukturiert. Unter dem jeweiligen Modellnamen befindet sich eine Liste der verfügbaren Explores, die in diesem Modell definiert sind.
  2. Nutzer können nach einem bestimmten Explore suchen.

  3. Entwickler können Beschreibungen für Explores definieren, die Nutzer aufrufen können, indem sie im Menü Explore den Mauszeiger auf den Explore-Namen bewegen.

  4. Der Bereich „Feldauswahl“ ist nach Ansichtsnamen strukturiert. Unter dem jeweiligen Ansichtsnamen befindet sich eine Liste der verfügbaren Felder aus den Tabellen, die in dieser Ansicht enthalten sind. In den meisten Ansichten werden sowohl Dimensionen als auch Messwerte angezeigt. In diesem Beispiel wird die Dimension Month aus der Dimensionsgruppe Returned Date 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 Pivottabellen anwenden.

  7. Nutzer können die Bedingungen der Abfrage verfeinern.

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

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

Codebeispiel

Das folgende Codebeispiel zeigt ein minimales LookML-Projekt für einen E-Commerce-Store 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'
  }
}

Zusätzliche Ressourcen

Wenn Sie noch keine Erfahrung mit der LookML-Entwicklung haben, können Sie die in den folgenden Abschnitten beschriebenen Ressourcen nutzen, um schneller zu lernen:

Zugang zur Looker-Lernumgebung erhalten

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

Daten mithilfe von Looker abfragen und analysieren

Kenntnisse über die Datenanalyse in Looker erleichtern Ihnen die Modellierung von Daten in LookML. Wenn Sie nicht mit der Verwendung von Looker zum Abfragen, Filtern und Untersuchen von Daten vertraut sind, empfehlen wir Ihnen 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, 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 erlernt haben, finden Sie auf den folgenden Seiten eine Übersicht über die verschiedenen Arten von LookML-Parametern: