SQL-Konzepte für Ansichten

In jeder Ansichtsdatei in Ihrem LookML-Projekt wird eine einzelne Ansicht in Looker definiert. Darin wird eine Tabelle angegeben, die abgefragt werden soll, und 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 werden die folgenden Themen behandelt:

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

Die Ansicht

Hier sehen Sie ein Beispiel für eine Ansichtsdatei mit dem Namen users.view, die Definitionen für die Datenbanktabelle enthält, die zusammen mit mehreren Dimensionen und Messwerten abgefragt wird:

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 Ansichtsdefinition ist der Parameter sql_table_name, mit dem die Tabelle in Ihrer Datenbank angegeben wird, die von einer Ansicht abgefragt wird. Dieser Wert ist die einzige Stelle im gesamten Modell, an der der Tabellenname definiert wird, da für alle anderen Verweise auf die Ansicht der Tabellenalias ${TABLE} verwendet wird. Wenn Sie den Namen der Datenbanktabelle ändern möchten, müssen Sie ihn nur im Parameter sql_table_name ändern. Beim Verweisen auf eine Datenbanktabelle sind einige Punkte zu beachten.

Looker verwendet den sql_table_name-Wert, um die SQL-FROM-Klausel zu schreiben, gefolgt vom Ansichtsnamen, der zum Tabellenalias wird. Das SQL-Äquivalent sieht so aus:

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

Looker verwendet die in der Ansicht definierten Dimensionen und Messwerte, um die SQL-SELECT-Anweisung zu generieren. Jede Dimension definiert den Typ der Dimension, z. B. „string“, „number“ oder „boolean“, und einen sql-LookML-Parameter, der mit dem Tabellenalias auf die Dimension in der Ansicht verweist. Hier ein Beispiel für eine Dimension namens age:

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

Wenn Looker den SQL-Code erstellt, der an Ihre Datenbank gesendet werden soll, wird der Alias für die Ansicht in ${TABLE} eingesetzt. Für die Dimension age aus dem vorherigen Beispiel würde Looker eine SELECT-Anweisung wie die folgende generieren:

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

Messwerte sind oft Aggregationen, die für Dimensionen ausgeführt werden. Sie geben den Alias für die Dimension im sql-Ausdruck eines Messwerts an. Ein Messwert, mit dem der Durchschnitt der Dimension age berechnet wird, 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 an alle Aliasreferenzen der Dimension weitergegeben.

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 nachzubilden.

SQL-Ausdruck verwenden

Angenommen, Sie möchten die Altersdaten in vier Kohorten unterteilen: Nutzer unter 18 Jahren als „Jugendliche“, Nutzer zwischen 18 und 35 Jahren als „Junge Erwachsene“, Nutzer zwischen 36 und 65 Jahren als „Erwachsene“ und Nutzer ab 65 Jahren als „Senioren“. 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-Dimensionsdefinition 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 Ihre Alterskohorte als Dimension definiert haben, können Sie die CASE-Logik wiederverwenden, indem Sie die Dimension „Alterskohorte“ in Ihre Explore-Abfragen einbeziehen.

Wenn Sie eine Explore-Abfrage mit der Dimension „Alterskohorte“ erstellen, können Sie auf dem Tab „SQL“ des Explores den von Looker generierten SQL-Code ansehen. Mit der Dimension „Alterskohorte“ sieht der SQL-Code 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

Sie können mit einem datenbankunabhängigen Ausdruck 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 zum Beschriften der Ergebnisse zu erfassen.

Im Folgenden sehen Sie ein Beispiel für dieselbe neue Dimension age_cohort, die mit dem LookML-Parameter case geschrieben wird:

  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 erstellt 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 Looker-Logik für Klassen oder Stufen verwenden

Eine weitere Methode zum Angeben, wie numerische Werte gruppiert werden sollen, verwendet die integrierten Looker-Parametertypen bin oder tier. Der Parameter type:bin wird in Verbindung mit dem Parameter bins verwendet. Der Parameter type: tier wird in Verbindung mit dem Parameter tiers verwendet, um eine numerische Dimension in eine Reihe von Zahlenbereichen zu unterteilen. Der Nachteil ist, dass Sie keine Labels für die einzelnen Klassen definieren können.

Im folgenden LookML-Beispiel wird der Parameter bins in einer Dimension verwendet, um den Mindestwert in jeder Gruppe 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 wie die folgende:

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