SQL-Konzepte für Ansichten

Jede Ansichtsdatei in Ihrem LookML-Projekt definiert eine einzelne Ansicht in Looker, in der eine abzufragende Tabelle und die Felder (Dimensionen und Messwerte) aus dieser Tabelle angegeben werden, die in der Looker-UI angezeigt werden. Eine Ansicht entspricht entweder einer einzelnen Tabelle in Ihrer Datenbank oder einer einzelnen abgeleiteten Tabelle.

In dieser Anleitung erfahren Sie mehr zu folgenden Themen:

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

Die Ansicht

Hier ist ein Beispiel für eine Ansichtsdatei mit dem Namen users.view, die Definitionen für die abzufragende Datenbanktabelle sowie mehrere Dimensionen und Messwerte enthält:

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 sql_table_name Parameter, der die Tabelle in Ihrer Datenbank angibt, die von einer Ansicht abgefragt wird. Dieser Wert ist die einzige Stelle im gesamten Modell, an der der Tabellenname definiert ist, da alle anderen Verweise auf die Ansicht den Tabellenalias ${TABLE} verwenden. Wenn Sie den Namen der Datenbanktabelle ändern möchten, muss er nur im Parameter sql_table_name geändert werden. Es gibt einige Dinge, die Sie beachten sollten, wenn Sie auf eine Datenbanktabelle verweisen.

Looker verwendet den Wert sql_table_name, 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 definierten Dimensionen und Messwerte der Ansicht, um die SQL-SELECT-Klausel zu generieren. Jede Dimension definiert den Typ der Dimension, z. B. String, Zahl oder boolescher Wert, und einen sql LookML-Parameter, der mit dem Tabellenalias auf die Dimension in der Ansicht verweist. Ein Beispiel für eine Dimension mit dem Namen age:

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

Wenn Looker das SQL erstellt, das an Ihre Datenbank gesendet werden soll, 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 erstellen:

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

Messwerte sind oft Aggregationen, die für Dimensionen ausgeführt werden. Sie geben den Dimensionsalias im sql-Ausdruck eines Messwerts an. Ein Messwert, der den Durchschnitt der age Dimension 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 an alle Verweise auf den Dimensionsalias 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 „Ältere Erwachsene“ und Nutzer ab 65 Jahren als „Senioren“. Um diese Unterteilung vorzunehmen, müssen Sie eine neue Dimension definieren, z. B. dimension: age_cohort, mit einem sql-Ausdruck, der diese Kohorten erfasst. Die folgende LookML-Dimensionsdefinition verwendet eine CASE-Anweisung, 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 Explore das von Looker generierte SQL ansehen. Mit der Dimension „Alterskohorte“ sieht das SQL 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 case-Parameter können Sie die Kohorten-Buckets definieren, die aus when-Anweisungen bestehen, die sql-Ausdrücke verwenden, um bestimmte Bedingungen und Strings zum Labeln der Ergebnisse zu erfassen.

Hier ist ein Beispiel für dieselbe neue Dimension age_cohort, die mit dem LookML-Parameter case geschrieben wurde:

  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, sodass die resultierenden Labels nicht nur alphanumerisch sortiert werden (es sei denn, Sie definieren die Sortierreihenfolge als alphanumerisch). Looker erstellt eine resultierende 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 Tier-Logik von Looker verwenden

Eine weitere Methode zum Angeben, wie numerische Werte gruppiert werden sollen, verwendet die integrierten LookML-Parametertypen bin oder tier. type:bin wird in Verbindung mit dem Parameter bins verwendet. Ebenso wird type: tier 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 Bins definieren können.

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

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

Sie können den Parameter tiers in einer Dimension genau so 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