Gängige LookML-Muster

Auf dieser Seite werden die folgenden gängigen Muster in LookML beschrieben:

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

Looker konvertiert LookML-Feldnamen in die Zeichenfolgen, die von der Benutzeroberfläche angezeigt werden, indem der Ansichtsname in normaler Schriftart mit dem fett formatierten Kurznamen des Felds kombiniert wird. Ein Feld namens Betrag in der Ansicht Bestellungen würde beispielsweise in der Benutzeroberfläche als Betrag für Bestellungen angezeigt werden. Auf dieser Seite sind beide Feldnamen fett formatiert und der Ansichtsname in Großbuchstaben (ORDERS Amount) geschrieben, um die Diskussion leichter verständlich zu machen.

Wenn ein Feld einen anderen Namen als der Spaltenname in einer Tabelle haben soll, ändern Sie den Feldnamen und verwenden Sie den Parameter sql, um das Feld mit der entsprechenden Spalte in der Tabelle zu verknüpfen. Im folgenden Beispiel enthält die Tabelle airports eine cntrl_twr-Spalte. 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 so umbenennen, dass sie für Menschen lesbar ist:

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 Land des Nutzers gruppieren, erfahren Sie, woher Ihre Bestellungen je nach Land stammen. Anzahl der Bestellungen Häufig ist es jedoch sinnvoll, eine Anzahl zu erstellen, die nach einem Dimensionswert gefiltert ist. Sie können beispielsweise eine neue Messung erstellen und sie ORDERS France Count nennen:

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 Benutzer 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, müssen Sie ihn in doppelte Anführungszeichen setzen:

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 Leistungsindikatoren werden in Prozent angegeben, z. B. „Prozentsatz der zurückgegebenen Artikel“, „Wie viel Prozent der E-Mails haben zu einem Verkauf geführt“, oder andere Fälle von "Prozentsatz von X und 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 durch Division durch Null zu vermeiden, konvertiert NULLIF(value, 0) einen Nullwert in null. Dadurch wird das Ergebnis zu null und es wird ein Fehler vermieden.

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 in der Benutzeroberfläche auf einen Messwert klicken, erstellt Looker einen neuen um das Dataset zu lokalisieren, aus dem der Messwert besteht. Jeder Wert wird für jede Dimension in der Tabellenzeile

Zum Anzeigen der Details benötigt Looker eine angegebene Liste von Aufschlüsselungsfeldern, die anzeigt, wann auf den Wert des Messwerts geklickt wurde. Wenn Sie ein Modell generieren, erstellt der Generator in der Regel einige anfängliche Aufschlüsselungsfelder. Darüber hinaus können Sie selbst weitere Drill-Felder hinzufügen. Angenommen, Sie haben in der letzten Woche die ORDERS-Anzahl nach NUTZER-Status gemessen. In Looker würde die Abfrage in etwa so aussehen:

BENUTZER BundesstaatAUFTRÄGE Anzahl
Kalifornien24
Texas5
Colorado4
Florida4
Illinois4

Wenn Sie in der Zeile Kalifornien auf 24 klicken, werden Ihnen die 24 Bestellungen aus Kalifornien angezeigt. In Looker wird zwar der Filter NUTZER Bundesstaat: Kalifornien hinzugefügt, Looker weiß aber nicht, welche Felder in der Reihenfolge angezeigt werden sollen. Zunächst müssen Sie einen Satz verwenden, um diese Felder in Ihrem Modell zu deklarieren.

In LookML ist ein Satz eine Liste von Feldnamen (Dimension, Messwert und Filter). Mithilfe von Sätzen geben Sie Looker die folgenden Informationen an:

  • Die Felder, die angezeigt werden sollen, wenn eine Anzahl oder ein anderer Messwert aufgeschlüsselt wird
  • Die Felder, die Sie beim Zusammenführen einer Ansicht importieren möchten
  • Die Felder, die in einem Explore indexiert 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

Ein Literal-Set ist eine einfache Möglichkeit, ein Set in LookML zu definieren, insbesondere wenn es nur einmal verwendet wird. Ein Literalsatz wird erstellt, indem der Satz als Array deklariert wird. Sie können Literalsätze mit [] deklarieren.

Dazu ein Beispiel:

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

In diesem Beispiel sollen die Felder id, name und city angezeigt werden.

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

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

Benannte Sätze

In der Ansicht customers sind zwei Anzahlen definiert: count und in_california_count. Wenn ein Nutzer entweder das Feld Anzahl oder das Feld In Kalifornien Anzahl in einem Explore aufschlüsselt, möchten Sie die Felder id, name und city anzeigen.

Anfangs mag es ausreichend erscheinen, diese Felder 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]
  }
}

Falls Sie jedoch ein neues Feld hinzufügen möchten (z. B. customers.state), müssen Sie beide Listen bearbeiten, es sei denn, Sie haben den Parameter set zum Erstellen benannter Sätze verwendet, die Sie an einem Ort verwalten und an mehreren Orten verwenden können.

Mit dem folgenden Code wird ein Satz customers.detail erstellt, der beide Anzahlen auf denselben Satz von Feldern verweist.

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-Sets sind auf folgende Weise leistungsfähig:

  • Die Erneute Deklaration von Mengen ist additiv. Wenn Sie einen Satz an mehreren Stellen deklarieren, berücksichtigt Looker alle Felder, die für den Satz deklariert wurden.
  • 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 einen Bindestrich vor den Feldnamen setzen, z. B. -fieldname.

Aufschlüsselungsvisualisierungen anpassen

Wenn der Looker-Administrator die Labs-Funktion Visual Drilling aktiviert hat, werden Aufschlüsselungsvisualisierungen von „Ansehen und Erkunden“ nicht immer standardmäßig als Datentabelle verwendet. In diesem Fall können Sie die angezeigte Visualisierung anpassen, indem Sie Liquid-Variablen im Parameter link verwenden, wie auf der Dokumentationsseite zum Parameter link und auf der Seite mit den Best Practices für Effektivere Datenaufschlüsselung gezeigt.

Dashboards unterstützen eine visuelle Aufschlüsselung mithilfe des link-Parameters, ohne dass die Labs-Funktion Visual Drilling 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 auf dem explorativen Analysetool

Verwenden Sie always_filter, um immer eine Reihe von Filtern auf jede Abfrage anzuwenden, die in einem Explore ausgeführt wird. Die Filter werden in der Looker-Benutzeroberfläche angezeigt. Benutzer können den von Ihnen angegebenen Standardfilterwert zwar ändern, die Filter jedoch nicht entfernen. Im Allgemeinen werden diese Filter verwendet, um Daten zu entfernen, die normalerweise nicht eingeschlossen werden sollen. Angenommen, Sie möchten im Explore Orders (Aufträge) nur Aufträge sehen, die abgeschlossen oder ausstehend waren. Sie könnten den folgenden LookML-Code hinzufügen:

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

Wenn der Nutzer Bestellungen mit anderen Statuswerten sehen möchte, kann er den ORDERS Status in der Benutzeroberfläche auf % setzen.

sql_always_where auf dem explorativen Analysetool

Wenn Sie eine Abfrageeinschränkung anwenden möchten, die Nutzer nicht ändern können, können Sie sql_always_where verwenden. Neben den von menschlichen Benutzern ausgeführten Abfragen gilt diese Beschränkung für Dashboards, geplante Looks und eingebettete Informationen, die auf dieses Explore zurückgreifen. Eine sql_always_where-Bedingung wird dem Nutzer nur dann angezeigt, wenn er sich die zugrunde liegende SQL-Abfrage der von ihm erstellten Abfragen ansieht.

Das folgende Beispiel verhindert, dass Benutzer 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 auf dem explorativen Analysetool

Bei besonders 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. LookML bietet eine Lösung dafür in Form von conditionally_filter.

Sie verwenden den Parameter conditionally_filter, um einen Filter auf die Abfrage anzuwenden, es sei denn, der Nutzer hat bereits einen Filter für eines der im Abschnitt unless aufgeführten Felder hinzugefügt.

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

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