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. Sie benötigen keine Vorkenntnisse in Programmiersprachen, um LookML zu verstehen. LookML ist von bestimmten SQL-Dialekten unabhängig und enthält SQL-Ausdrücke, um jede SQL-Implementierung zu unterstützen.

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äftsanwender können die Ergebnisse dann verwenden, um komplexe Abfragen in Looker zu erstellen, wobei sie sich nur auf die benötigten Inhalte konzentrieren und nicht auf die Komplexität der SQL-Struktur.

LookML-Projekte

LookML ist 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 darüber, welche Tabellen im Projekt verwendet werden und wie die Tabellen 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. Fachkräfte für Datenanalyse verwenden LookML, um Datenmodelle zu erstellen und zu pflegen, die die Datenstruktur und Geschäftsregeln für die zu analysierenden Daten definieren. Der SQL-Generator von Looker übersetzt LookML in SQL, sodass Geschäftsanwender Abfragen ohne LookML oder SQL schreiben können.

Geschäftliche Nutzer verwenden den Looker Query Builder oder die Explore-Benutzeroberfläche, um Abfragen zu erstellen, die auf dem von den Looker-Analysten definierten Datenmodell basieren. 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 für die Datenbank ausgeführt und Looker gibt dann die formatierten Ergebnisse in der Explore-Benutzeroberfläche an den Benutzer zurück. Die Nutzenden können dann die Ergebnisse visualisieren und Erkenntnisse generieren.

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

Was Nutzer sehen

Die Einrichtung des Projekts und der spezifische Inhalt seiner Dateien bestimmen, was Benutzer sehen und wie sie mit Looker interagieren können.

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

  3. Entwickler können Beschreibungen für Explores definieren, die Nutzer sehen können, 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. Benutzer können mehrere Kennzahlen auswählen, auf denen die Abfrage basieren soll.

  6. Nutzer können Optionen wie Filter und Pivots im Feldauswahlbereich 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. Durch das Ausführen dieses Explores wird eine SQL-Abfrage generiert, die sowohl eine Datentabelle als auch eine Visualisierung des Gesamtverkaufspreises und der gesamten Bruttomarge der zurückgegebenen Aufträge des vergangenen Jahres zurückgibt.

Codebeispiel

Das folgende Codebeispiel zeigt ein minimales LookML-Projekt für einen E-Commerce-Store, das eine Modelldatei (ecommercestore.model.lkml) und zwei Ansichtsdateien (orders.view.lkml und customers.view.lkml) enthält:

######################################
# 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 mit der LookML-Entwicklung noch nicht vertraut sind, können Sie die in den folgenden Abschnitten beschriebenen Ressourcen nutzen, um den Lernprozess 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

Wenn Sie Ihre Daten in LookML modellieren, ist es für Sie sehr hilfreich, Daten in Looker zu untersuchen. Wenn Sie mit der Verwendung von Looker zum Abfragen, Filtern und Aufschlüsseln von Daten nicht vertraut sind, empfehlen wir die folgenden Ressourcen:

Machen Sie sich mit den SQL-Grundlagen vertraut, bevor Sie mit LookML arbeiten.

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 LookML-Grundlagen kennengelernt haben, finden Sie auf den folgenden Seiten einen Überblick über die verschiedenen Arten von LookML-Parametern: