Gängige LookML-Muster

Auf dieser Seite werden die folgenden häufigen Muster in LookML beschrieben:

• Bezeichnungen für Felder (und Namen in der Benutzeroberfläche)
• Anzahl anhand einer Dimension filtern
• Prozentsätze
• Sätze für Drilldown-Details verwenden
• Ergebnissätze filtern

Bezeichnungen für Felder (und Namen in der Benutzeroberfläche)

Looker konvertiert LookML-Feldnamen in die Zeichenfolgen, die auf der Benutzeroberfläche angezeigt werden, indem der Ansichtsname in normaler Schriftart mit dem fett formatierten Kurznamen des Feldes kombiniert wird. Ein Feld namens Menge in der Ansicht Bestellungen wird beispielsweise in der Benutzeroberfläche als „Bestellungen: Menge“ angezeigt. Zur besseren Veranschaulichung werden auf dieser Seite beide Feldnamen fett formatiert, und der Ansichtsname ist in Großbuchstaben geschrieben (AUFTRÄGE Betrag).

Wenn ein Feld einen anderen Namen als den Spaltennamen in einer Tabelle haben soll, ändern Sie den Feldnamen und verknüpfen Sie das Feld mit der entsprechenden Spalte in der Tabelle. Verwenden Sie dazu den Parameter sql. Im folgenden Beispiel enthält die Tabelle airports die Spalte cntrl_twr. In diesem Fall würde Looker die folgende Deklaration generieren:

view: airports {
  dimension: cntrl_twr {        # full name: airports.cntrl_twr
    type: yesno                 # default name: AIRPORT Cntrl Twr (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;  # the sql expression for this field
  }
}

Sie können die Dimension cntrl_twr in einen für Menschen lesbaren Namen umbenennen:

view: airports {
  dimension: has_control_tower {  # full name: airports.has_control_tower
    type: yesno                   # aliased name: AIRPORTS Has Control Tower (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;    # the sql expression for this field
  }
}

Anzahl anhand einer Dimension filtern

Sie können nach einer Dimension gruppieren und Entitäten zählen. Wenn Sie nach NUTZER Land und BESTELLUNGEN Anzahl gruppieren, sehen Sie, aus welchen Ländern Ihre Bestellungen stammen. Oftmals ist es jedoch sinnvoll, eine Anzahl zu erstellen, die anhand eines Dimensionswerts gefiltert wird. Sie könnten beispielsweise einen neuen Messwert namens ORDERS France Count erstellen:

view: users {
  dimension: country {}
}
view: orders {
  dimension: id {
    primary_key: yes
    sql: ${TABLE}.id ;;
  }
  measure: count {
    type: count
    drill_fields: [detail]
  }
  measure: france_count {
    type: count   # COUNT(CASE WHEN users.country = 'France' THEN 1 ELSE NULL END)
    filters: [users.country: "France"]
  }
}

Filter können jeden beliebigen Ausdruck verwenden. Wenn Sie ein Feld benötigen, das die Nutzer aus der gesamten EU zählt, könnten Sie dies folgendermaßen umsetzen:

measure: eu_count {
  type: count   # COUNT(CASE WHEN users.countrycode IN 'UK','FR','ES' THEN 1 ELSE NULL END)
  drill_fields: [detail]
  filters: [users.countrycode: "UK,FR,ES"]
}

Wenn Sie mit einem mathematischen Ausdruck filtern möchten, setzen Sie ihn in doppelte Anführungszeichen:

measure: total_orders_above_100_dollars {
  type: sum   # SUM(CASE WHEN order.value > 100 THEN order.value ELSE NULL END)
  sql: ${order.value} ;;
  drill_fields: [detail]
  filters: [order.value: ">100"]
}

Prozentsätze

Viele Leistungskennzahlen werden als Prozentsätze angegeben, z. B. „Prozentsatz der zurückgesendeten Artikel“, „Prozentsatz der E-Mails, die zu einem Kauf geführt haben“ oder andere Formen von „Prozentsatz von X an Y“. Dem Gestaltungsmuster von LookML entsprechend werden die Anzahl für die zwei Bedingungen und dann ein drittes Feld erstellt, das das prozentuale Verhältnis zwischen den beiden berechnet.

dimension: returned {
  type: yesno
}
measure: count {   # total count of items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
}
measure: returned_count {   # count of returned items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
  filters: [returned: "Yes"]
}
measure: percent_returned {
  type: number
  sql: 100.0 * ${returned_count} / NULLIF(${count}, 0) ;;
  value_format: "0.00"
}

Verwenden Sie das folgende Format, um Prozentsätze zu berechnen. In Postgres ist die Anzahl eine Ganzzahl, und die Division von Ganzzahlen ergibt wiederum Ganzzahlen. Durch Multiplikation mit 100,0 wird die erste Anzahl in eine Gleitkommazahl umgerechnet, wodurch auch der Rest des Ausdrucks zu einem Gleitkommawert wird. Um Fehler aufgrund einer Division durch Null zu vermeiden, wandelt NULLIF(value, 0) einen Nullwert in Null um, was zum Ergebnis Null führt und keinen Fehler ergibt.

100.0 * ${returned_count} / NULLIF(${count}, 0)

Sätze für Drilldown-Details verwenden

Zu den stärksten Funktionen von Looker gehört unter anderem die Fähigkeit, Daten so aufzuschlüsseln, dass die zugrunde liegenden Entitäten sichtbar werden, aus denen eine Anzahl oder ein anderer Messwert besteht.

Wenn Sie auf einen Messwert in der Benutzeroberfläche klicken, erstellt Looker eine neue Abfrage, um den Datensatz zu lokalisieren, aus dem der Messwert besteht. Jeder Wert für jede Dimension in der Tabellenzeile wird den

Zum Anzeigen der Details benötigt Looker eine festgelegte Liste mit Drill-Feldern, um anzuzeigen, dass auf den Wert des Messwerts geklickt wurde. Wenn Sie ein Modell generieren, erstellt der Generator in der Regel einige anfängliche Drill-Felder für Sie. Darüber hinaus können Sie selbst weitere Drill-Felder hinzufügen. Angenommen, Sie messen die ANZAHL DER BESTELLUNGEN nach BENUTZER Bundesstaat in der letzten Woche. In Looker würde die Abfrage in etwa so aussehen:

BENUTZER Bundesstaat	AUFTRÄGE Anzahl
Kalifornien	24
Logo: Texas	5
Colorado	4
Florida	4
Illinois	4

Wenn Sie in der Zeile Kalifornien auf 24 klicken, werden normalerweise die 24 Aufträge aus Kalifornien angezeigt. Looker fügt zwar den Filter USERS State: California hinzu, weiß aber nicht, welche Felder im Auftrag angezeigt werden sollen. Dazu müssen Sie zuerst einen Satz verwenden, um diese Felder in Ihrem Modell zu deklarieren.

In LookML ist ein Set eine Liste von Feldnamen (Dimensionen, Messwerte und Filter). Mithilfe von Sets geben Sie Looker die folgenden Informationen:

• Die Felder, die angezeigt werden sollen, wenn Sie eine Anzahl oder einen anderen Messwert aufschlüsseln
• Die Felder, die beim Zusammenführen einer Ansicht importiert werden sollen
• Die Felder, die in einem Explore indiziert werden sollen

Da derselbe Satz an vielen Stellen in einem Modell verwendet werden kann, bietet Looker mehrere Methoden zum Erstellen von Sätzen.

Literalsätze

Mit einem Literalsatz können Sie einen Satz in LookML ganz einfach definieren, insbesondere wenn er nur einmal verwendet wird. Ein Literalsatz entsteht dadurch, dass der Satz als Array deklariert wird. Sie können Literalsätze mithilfe von [] deklarieren.

Dazu ein Beispiel:

view: customers {
  dimension: id {
    primary_key: yes
  }
  measure: count {
    type: count
  }
  dimension: city {}
  dimension: state {}
  dimension: name {}
}

In diesem Beispiel sind das die Felder id, name und city.

Im Messwert können Sie ein Literal-Array so deklarieren:

measure: count {
  type: count
  drill_fields: [id, name, city]
}

Benannte Sätze

Angenommen, in der Ansicht customers sind zwei Anzahlwerte definiert: count und in_california_count. Wenn ein Nutzer in einem Explore das Feld Anzahl oder das Feld Anzahl in Kalifornien aufschlüsselt, sollen die Felder id, name und city angezeigt werden.

Zuerst mag es ausreichend erscheinen, diese Felder als Literale zu deklarieren:

view: customers {
  measure: count {
    type: count
    drill_fields: [id, name, city]
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [id, name, city]
  }
}

Wenn Sie jedoch ein neues Feld hinzufügen möchten (z. B. customers.state), müssen Sie beide Listen bearbeiten, es sei denn, Sie haben mit dem set-Parameter benannte Sätze erstellt, die Sie an einer Stelle verwalten und an mehreren Stellen verwenden können.

Mit dem folgenden Code wird ein Satz customers.detail erstellt, sodass beide Anzahlen auf denselben Satz Felder verweisen.

view: customers {
  set: detail {
    fields: [id, name, city]      # creates named set customers.detail
  }

  measure: count {
    type: count
    drill_fields: [detail*]       # show fields in the set "customers.detail"
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

LookML-Sätze bieten folgende Vorteile:

• Die Neudeklarierung von Sets ist additiv. Wenn Sie einen Satz an mehreren Stellen deklarieren, berücksichtigt Looker alle für den Satz deklarierten Felder an allen Orten.
• Sie können Sätze in andere Sätze einbetten, indem Sie den Namen des anderen Satzes gefolgt von einem Sternchen eingeben, z. B. setname*.
• Sie können Elemente aus Sätzen entfernen, indem Sie vor den Feldnamen einen Bindestrich setzen, z. B. -fieldname.

Aufschlüsselungsvisualisierungen anpassen

Wenn Ihr Looker-Administrator die Labs-Funktion Visuelle Aufschlüsselung aktiviert hat, werden für Look- und Explore-Aufschlüsselungsvisualisierungen nicht immer standardmäßig Datentabellen verwendet. In diesem Fall können Sie die angezeigte Visualisierung mithilfe von Liquid-Variablen im Parameter link anpassen, wie auf der Seite mit der Parameterdokumentation link und auf der Seite mit Best Practices für Erweiterte Datenaufschlüsselung gezeigt.

Dashboards unterstützen das visuelle Untersuchen mit dem Parameter link, ohne dass die Labs-Funktion Visuelles Untersuchen aktiviert werden muss.

Ergebnissätze filtern

LookML bietet eine Reihe von Filtervorgängen, die auf Felder angewendet werden können, sowie Explores zum Filtern von Ergebnissätzen, bevor sie an den Benutzer übergeben werden.

always_filter in der explorativen Datenanalyse

Verwenden Sie always_filter, damit auf jede innerhalb eines Explores ausgeführte Abfrage eine Reihe von Filtern angewendet wird. Die Filter werden auf der Benutzeroberfläche von Looker angezeigt. Die Nutzer können zwar den von Ihnen vorgegebenen Standard-Filterwert ändern, die Filter jedoch nicht löschen. Grundsätzlich werden diese Filter eingesetzt, um Daten zu löschen, die normalerweise nicht berücksichtigt werden sollen. Angenommen, im Explore Bestellungen sollen nur Aufträge angezeigt werden, die abgeschlossen (complete) oder ausstehend (pending) sind. Sie könnten den folgenden LookML-Code hinzufügen:

explore: orders {
  view_name: order
    filters: [status: "complete,pending"]
  }
}

Wenn der Nutzer Aufträge mit anderen Statuswerten abrufen möchte, könnte er die Benutzeroberfläche ORDERS Status auf % setzen.

sql_always_where in der explorativen Datenanalyse

Wenn Sie eine Abfragebeschränkung anwenden möchten, die nicht von Nutzern geändert werden kann, können Sie sql_always_where verwenden. Neben den von menschlichen Nutzern ausgeführten Abfragen gilt diese Beschränkung für Dashboards, geplante Looks und eingebettete Informationen, die auf dieses Explore zurückgreifen. Dem Nutzer wird nur dann eine sql_always_where-Bedingung angezeigt, wenn er sich den zugehörigen SQL-Code seiner selbst erstellten Abfragen ansieht.

Das folgende Beispiel verhindert, dass Nutzer Aufträge vor dem 01.01.2012 zu sehen bekommen:

# Using Looker references
explore: order {
  sql_always_where: ${created_date} >= '2012-01-01' ;;
}

# Using raw SQL
explore: order {
  sql_always_where: DATE(created_time) >= '2012-01-01' ;;
}

conditionally_filter in der explorativen Datenanalyse

Bei sehr großen Tabellen müssen Abfragen sorgfältig überdacht werden, da eine unbegrenzte Anzahl von Abfragen schnell zu einer Belastung für die Datenbank werden kann. In LookML können Sie dieses Problem mithilfe von conditionally_filter beheben.

Mit dem Parameter conditionally_filter wenden Sie einen Filter auf die Abfrage an, es sei denn, der Nutzer hat für eines der Felder, die im Abschnitt unless aufgeführt werden, einen Filter hinzugefügt.

Im folgenden Beispiel wird die Suchanfrage des Nutzers nicht geändert, wenn er einen Filter auf eines oder mehrere der folgenden Felder angewendet hat: created_date, shipped_time, shipped_date, orders.id oder customer.name. Hat der Nutzer nicht nach einem dieser Felder gefiltert, fügt Looker automatisch einen Filter für 1 Tag zu orders.created_time hinzu.

  filters: [orders.created_time: "1 day"]
  unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}