SQL-Konzepte für Ansichten

Jede Ansichtsdatei in Ihrem LookML-Projekt definiert eine einzelne Ansicht in Looker. Dabei wird eine abzufragende Tabelle und festgelegt, welche Felder (Dimensionen und Messwerte) aus dieser Tabelle in der Looker-Benutzeroberfläche angezeigt werden. Eine Ansicht entspricht entweder einer einzelnen Tabelle in Ihrer Datenbank oder einer einzelnen abgeleiteten Tabelle.

In diesem Leitfaden erfahren Sie Folgendes:

Weitere Informationen zum Definieren und Anpassen abgeleiteter Tabellen in LookML mit SQL finden Sie unter SQL-Konzepte für abgeleitete Tabellen.

Die Ansicht

Hier ein Beispiel für eine Ansichtsdatei namens users.view mit Definitionen für die Datenbanktabelle, die abgefragt werden soll, sowie mehreren Dimensionen und Messwerten:

view: users {
  sql_table_name: thelook.users ;;

  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }
   measure: average_age {
    type: average
    sql: ${age} ;;  }

  dimension_group: created {
    type: time
    timeframes: [raw, time, date, week, month, quarter, year]
    sql: ${TABLE}.created_at ;;
  }

  measure: count {
    type: count
  }
}

Das erste Element der Definition der Ansicht ist der Parameter sql_table_name, mit dem die Tabelle in Ihrer Datenbank angegeben wird, die von einer Ansicht abgefragt wird. An diesem Wert wird der Tabellenname nur einmal im gesamten Modell definiert, da für alle anderen Verweise auf die Ansicht der Tabellenalias ${TABLE} verwendet wird. Wenn Sie den Namen der Datenbanktabelle ändern möchten, muss dies nur im Parameter sql_table_name erfolgen. Wenn Sie auf eine Datenbanktabelle verweisen, gibt es einige wichtige Dinge zu beachten.

Looker verwendet den Wert sql_table_name, um die SQL-FROM-Klausel zu schreiben, gefolgt vom Namen der Ansicht, der zum Tabellenalias wird. Die SQL-Entsprechung würde so aussehen:

FROM `thelook`.`users` AS `users`

Looker verwendet die definierten Dimensionen und Messwerte der Ansicht, um die SQL-SELECT-Klausel zu generieren. Für jede Dimension wird der Typ der Dimension (z. B. String, Zahl oder Boolescher Wert) und ein sql LookML-Parameter definiert, der über den Tabellenalias auf die Dimension in der Ansicht verweist. Im folgenden Beispiel wird eine Dimension namens age verwendet:

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }

Wenn Looker die SQL-Abfrage erstellt, die an Ihre Datenbank gesendet wird, ersetzt Looker den Alias für die Ansicht durch ${TABLE}. Für die Dimension age aus dem vorherigen Beispiel würde Looker eine SELECT-Klausel wie die folgende generieren:

SELECT `users`.`age` AS `users.age`

Messwerte sind oft Zusammenfassungen, die auf Dimensionen ausgeführt werden. Den Alias der Dimension geben Sie im sql-Ausdruck eines Messwerts an. Ein Messwert, der den Durchschnitt der Dimension age berechnet, kann beispielsweise einen sql-Ausdruck mit dem Alias ${age} enthalten, wie im folgenden Beispiel:

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }

  measure: average_age {
    type: average
    sql: ${age} ;;
  }

Wenn Sie die Dimension age umbenennen, wird der neue Alias auf alle Verweise auf den Dimensionsalias angewendet.

Ansichtsdatei anpassen

Sie können die SQL-Ausdrücke Ihrer Ansichtsdatei anpassen oder die integrierte LookML-Logik von Looker verwenden, um die Logik eines SQL-Ausdrucks nachzuahmen.

SQL-Ausdruck verwenden

Angenommen, Sie möchten die Altersdaten in vier Kohorten unterteilen, wobei Nutzer unter 18 Jahren als „Jugendliche“, Nutzer zwischen 18 und 35 Jahren als „Junge Erwachsene“, Nutzer zwischen 36 und 65 Jahren als „Ältere Erwachsene“ und Nutzer ab 65 Jahren als „Senioren“ definiert werden. Dazu müssen Sie eine neue Dimension definieren, z. B. dimension: age_cohort, mit einem sql-Ausdruck, der diese Kohorten erfasst. In der folgenden LookML-Definition für eine Dimension wird eine CASE-Anweisung verwendet, die für eine MySQL-Datenbankverbindung geeignet ist:

dimension: age_cohort {
  type: string
  sql:
    CASE
      WHEN ${age} < 18 THEN 'Youth'
      WHEN ${age} < 35 THEN 'Young Adult'
      WHEN ${age} < 65 THEN 'Older Adult'
      ELSE 'Senior'
    END ;;
}

Nachdem Sie die Alterskohorte als Dimension definiert haben, können Sie die CASE-Logik wiederverwenden, indem Sie die Dimension „Alterskohorte“ in Ihre Explore-Abfragen aufnehmen.

Wenn Sie eine Explore-Abfrage mit der Dimension „Alterskohorte“ erstellen, können Sie auf dem Tab „SQL“ des Explores die von Looker generierte SQL-Abfrage aufrufen. Bei der Dimension „Alterskohorte“ sieht die SQL-Abfrage in etwa so aus:

SELECT
CASE
  WHEN users.age < 18 THEN 'Youth'
  WHEN users.age < 35 THEN 'Young Adult'
  WHEN users.age < 65 THEN 'Older Adult'
  ELSE 'Senior'
END  AS `users.age_cohort`,
AVG(`age`) AS `users.average_age`,
COUNT(*) AS `users.count`
FROM
  `thelook`.`users` AS `users`
GROUP BY
  1
ORDER BY
  2 DESC
LIMIT 500

Integrierte Falllogik von Looker verwenden

Mit einem datenbankunabhängigen Ausdruck können Sie denselben Effekt wie mit einer SQL-CASE-Anweisung erzielen. Mit dem LookML-Parameter case können Sie die Kohorten-Buckets definieren, die aus when-Anweisungen bestehen, in denen sql-Ausdrücke verwendet werden, um bestimmte Bedingungen und Strings für die Kennzeichnung der Ergebnisse zu erfassen.

Im folgenden Beispiel wird dieselbe neue age_cohort-Dimension mit dem LookML-Parameter case geschrieben:

  dimension: age_cohort {
    case: {
      when: {
        sql: ${age} < 18 ;;
        label: "Youth"
      }
      when: {
        sql: ${age} < 35 ;;
        label: "Young Adult"
      }
      when: {
        sql: ${age} < 65 ;;
        label: "Middle-aged Adult"
      }
      else: "Older Adult"
    }
  }

Zur Laufzeit erstellt Looker die richtige SQL-CASE-Syntax für Ihre Datenbank. Außerdem erstellt Looker einen weiteren Ausdruck, um die Gruppen zu sortieren. Die resultierenden Labels werden also nicht nur alphanumerisch sortiert, es sei denn, Sie definieren die Sortierreihenfolge als alphanumerisch. Looker generiert eine SQL-Abfrage, die in etwa so aussieht:

SELECT
CASE
  WHEN users.age < 18  THEN '0'
  WHEN users.age < 35  THEN '1'
  WHEN users.age < 65  THEN '2'
  ELSE '3'
END AS `users.age_cohort__sort_`,
CASE
  WHEN users.age < 18  THEN 'Youth'
  WHEN users.age < 35  THEN 'Young Adult'
  WHEN users.age < 65  THEN 'Older Adult'
  ELSE 'Senior'
END AS `users.age_cohort`,
AVG(`age`) AS `users.average_age`,
COUNT(*) AS `users.count`
FROM
  `thelook`.`users` AS `users`
GROUP BY
  1,
  2
ORDER BY
  1
LIMIT 500

Integrierte Bin- oder Stufenlogik von Looker verwenden

Eine weitere Methode zur Angabe der Gruppierung numerischer Werte sind die in Looker integrierten Parametertypen bin oder tier. Der Parameter type:bin wird in Verbindung mit dem Parameter bins verwendet. Ebenso wird der Parameter type: tier in Verbindung mit dem Parameter tiers verwendet, um eine numerische Dimension in eine Reihe von Nummernbereichen aufzuteilen. Der Nachteil ist, dass Sie keine Labels für jeden Bin definieren können.

Im folgenden LookML-Beispiel wird der Parameter bins in einer Dimension verwendet, um den Mindestwert in jedem Satz zu definieren:

  dimension: age_cohort {
    type: bin
    bins: [18,36,65]
    style: integer
    sql: ${age} ;;
  }

Sie können den Parameter tiers in einer Dimension auf genau dieselbe Weise verwenden. Beispiel:

  dimension: age_cohort {
    type: tier
    tiers: [18,36,65]
    style: integer
    sql: ${age} ;;
  }

Looker generiert dann eine SQL-Anweisung in etwa so:

SELECT
CASE
  WHEN users.age  < 18 THEN '0'
  WHEN users.age  >= 18 AND users.age  < 36 THEN '1'
  WHEN users.age  >= 36 AND users.age  < 65 THEN '2'
  WHEN users.age  >= 65 THEN '3'
  ELSE '4'
END AS `users.age_cohort__sort_`,
CASE
  WHEN users.age  < 18 THEN 'Below 18'
  WHEN users.age  >= 18 AND users.age  < 36 THEN '18 to 35'
  WHEN users.age  >= 36 AND users.age  < 65 THEN '36 to 64'
  WHEN users.age  >= 65 THEN '65 or Above'
  ELSE 'Undefined'
END AS `users.age_cohort`,
AVG(`age`) AS `users.average_age`,
COUNT(*) AS `users.count`
FROM
  `thelook`.`users` AS `users`
GROUP BY
  1,
  2
ORDER BY
  1
LIMIT 500