SQL-Konzepte für Ansichten

Mit jeder Ansichtsdatei in Ihrem LookML-Projekt wird eine einzelne Ansicht in Looker definiert, in der eine abzufragende Tabelle angegeben ist. Außerdem wird angegeben, welche Felder (Dimensionen und Messwerte) aus dieser Tabelle in der Looker-Benutzeroberfläche angezeigt werden. Eine Ansicht entspricht entweder einer einzelnen Tabelle in der 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.

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, der die Tabelle in Ihrer Datenbank angibt, die von einer Ansicht abgefragt wird. Dieser Wert ist der einzige Ort im gesamten Modell, an dem der Tabellenname definiert ist, 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, sollten Sie Folgendes 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. Hier ein Beispiel für eine Dimension mit dem Namen age:

  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. Sie geben den Dimensionsalias im Ausdruck sql 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 als „Jugendliche“, Nutzer im Alter von 18 bis 35 als „Junge Erwachsene“, Nutzer im Alter von 36 bis 65 als „Älter“ und Nutzer ab 65 als „Senior“ 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 Kohortendimension „Alter“ erstellen, können Sie auf dem SQL-Tab des Explores den von Looker generierten SQL-Code ansehen. Mit der Kohortendimension „Alter“ sieht die 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

Die integrierte Falllogik von Looker verwenden

Sie können die gleiche Wirkung wie eine SQL-CASE-Anweisung mit einem datenbankunabhängigen Ausdruck erzielen. Mit dem LookML-Parameter case können Sie die Kohorten-Buckets definieren, die aus when-Anweisungen bestehen, die sql-Ausdrücke verwenden, um bestimmte Bedingungen und Strings zum Beschriften der Ergebnisse zu erfassen.

Im Folgenden finden 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. Darüber hinaus erstellt Looker einen weiteren Ausdruck für das Sortieren der Gruppen, sodass die resultierenden Beschriftungen nicht nur alphanumerisch sortiert werden (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

Verwendung der integrierten Bin- oder Stufenlogik von Looker

Eine weitere Methode zum Angeben, wie numerische Werte gruppiert werden sollen, sind die in Looker integrierten Parametertypen bin oder tier. type:bin wird in Verbindung mit dem Parameter bins und type: tier in Verbindung mit dem Parameter tiers verwendet, um eine numerische Dimension in mehrere Zahlenbereiche zu unterteilen. 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 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