Mit Joins können Sie verschiedene Ansichten miteinander verknüpfen, um Daten aus mehreren Ansichten gleichzeitig zu analysieren und zu sehen, wie verschiedene Teile Ihrer Daten zusammenhängen.
Ihre Datenbank enthält beispielsweise die Tabellen order_items
, orders
und users
. Mithilfe von Joins können wir Daten aus all diesen Tabellen gleichzeitig analysieren. Auf dieser Seite werden Joins in LookML erläutert. Dies umfasst auch bestimmte Join-Parameter und Verbindungsmuster.
Joins beginnen mit einem Explore
Joins werden in der Modelldatei definiert, um die Beziehung zwischen einem Explore und einer Ansicht herzustellen. Joins verknüpfen eine oder mehrere Ansichten in einem einzelnen Explore, entweder direkt oder über eine andere verknüpfte Ansicht.
Betrachten Sie zwei Datenbanktabellen: order_items
und orders
. Nachdem Sie für diese beiden Tabellen Ansichten erstellt haben, können Sie eine davon oder mehrere in der Modelldatei mit dem explore
-Parameter deklarieren:
explore: order_items { ... }
Wenn Sie eine Abfrage über das Explore order_items
ausführen, wird order_items
in der FROM
-Klausel des generierten SQL-Codes angezeigt:
SELECT ...
FROM order_items
Sie können dem order_items
-Explore zusätzliche Informationen hinzufügen. Mit dem folgenden LookML-Beispiel können Sie beispielsweise die Ansicht orders
mit dem Explore order_items
verknüpfen:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
Der oben gezeigte LookML-Code bewirkt zwei Dinge. Zuerst sehen Sie im Feldauswahlfeld für Explorations Felder aus orders
und order_items
:
Zweitens beschreibt der LookML-Code, wie orders
und order_items
miteinander verknüpft werden. Dieser LookML-Code entspricht dem folgenden SQL-Code:
SELECT ...
FROM order_items
LEFT JOIN orders
ON order_items.order_id = orders.id
Diese LookML-Parameter werden in den nachfolgenden Abschnitten detaillierter beschrieben.
Join-Parameter
Für den Join werden vier Hauptparameter verwendet: join
, type
, relationship
und sql_on
.
1. Schritt: Das Explore starten
Erstellen Sie zuerst den order_items
-Explore:
explore: order_items { ... }
Schritt 2: join
Wenn Sie eine Tabelle verbinden möchten, müssen Sie sie zuerst in einer Ansicht deklarieren. In diesem Beispiel wird davon ausgegangen, dass orders
eine vorhandene Ansicht in Ihrem Modell ist.
Verwenden Sie dann den Parameter join
, um anzugeben, dass Sie die Ansicht orders
mit dem Explore order_items
verknüpfen möchten:
explore: order_items {
join: orders { ... }
}
Schritt 3: type
Überlegen Sie, welcher Join-Typ ausgeführt werden soll. Looker unterstützt LEFT JOIN
, INNER JOIN
, FULL OUTER JOIN
und CROSS JOIN
. Diese entsprechen den type
-Parameterwerten left_outer
, inner
, full_outer
und cross
.
explore: order_items {
join: orders {
type: left_outer
}
}
Der Standardwert von type
ist left_outer
.
Schritt 4: relationship
Definieren Sie eine Join-Beziehung zwischen dem Explore order_items
und der Ansicht orders
. Die ordnungsgemäße Deklaration der Beziehung eines Joins ist für die Berechnung korrekter Messwerte durch Looker erforderlich. Die Beziehung wird vom Explore order_items
zur Ansicht orders
definiert. Die möglichen Optionen sind one_to_one
, many_to_one
, one_to_many
und many_to_many
.
In diesem Beispiel kann es viele Auftragspositionen für einen einzelnen Auftrag geben. Die Beziehung zwischen dem Explore order_items
und der Ansicht orders
ist many_to_one
:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
}
}
Wenn Sie in Ihrem Join keinen relationship
-Parameter angeben, verwendet Looker standardmäßig many_to_one
.
Weitere Tipps zum korrekten Definieren des relationship
-Parameters für einen Join finden Sie unter relationship
-Parameter richtig festlegen.
Schritt 5: sql_on
Geben Sie an, wie die Tabelle order_items
und die Tabelle orders
mit dem Parameter sql_on
oder dem Parameter foreign_key
verknüpft werden sollen.
sql_on
Der Parameter sql_on
entspricht der ON
-Klausel im generierten SQL für eine Abfrage. Mit diesem Parameter können Sie deklarieren, welche Felder für den Join-Vorgang abgeglichen werden sollten:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
Wir können auch komplexere Joins formulieren. Beispiel: Sie möchten nur Aufträge verbinden, deren id
größer als 1.000 ist:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} AND ${orders.id} > 1000 ;;
}
}
Weitere Informationen zur ${ ... }
-Syntax in diesen Beispielen finden Sie in der Dokumentation zu Ersetzungsoperatoren.
6. Schritt: Testen
Ob dieser Join wie erwartet funktioniert, können Sie testen, indem Sie das Explore Bestellpositionen aufrufen. Sie sollten Felder aus order_items
und orders
sehen.
Weitere Informationen zum Testen von LookML-Änderungen in einem Explore finden Sie unter Felder im Explore testen.
Durch eine andere Ansicht verbinden
Sie können eine Ansicht über eine andere Ansicht mit einem Explore verbinden. Im Beispiel für Join-Parameter haben Sie orders
über das Feld order_id
mit order_items
verknüpft. Möglicherweise sollen zudem die Daten aus der Ansicht users
mit dem Explore order_items
verbunden werden, auch wenn kein gemeinsames Feld vorhanden ist. Dazu können Sie einen Join durch die Ansicht orders
vornehmen.
Verwenden Sie den Parameter sql_on
oder den Parameter foreign_key
, um die users
-Ansicht mit der orders
-Ansicht zu verknüpfen, anstatt mit der order_items
-Ansicht. Dazu müssen Sie den Bereich des Felds von orders
in orders.user_id
ändern.
Hier ein Beispiel für die Verwendung des Parameters sql_on
:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
join: users {
type: left_outer
relationship: many_to_one
sql_on: ${orders.user_id} = ${users.id} ;;
}
}
Eine Ansicht mehrmals verbinden
Eine users
-Ansicht enthält Daten für Käufer und Verkäufer. Wenn Sie Daten aus dieser Ansicht in order_items
einfügen möchten, aber separat für Käufer und Verkäufer, können Sie users
zweimal mit unterschiedlichen Namen mithilfe des Parameters from
einfügen.
Mit dem Parameter from
können Sie festlegen, welche Ansicht bei einem Join verwendet werden soll. Gleichzeitig erhält der Join einen eindeutigen Namen. Beispiel:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
join: buyers {
from: users
type: left_outer
relationship: many_to_one
sql_on: ${orders.buyer_id} = ${buyers.id} ;;
}
join: sellers {
from: users
type: left_outer
relationship: many_to_one
sql_on: ${orders.seller_id} = ${sellers.id} ;;
}
}
In diesem Fall werden nur Käuferdaten als buyers
und nur Verkäuferdaten als sellers
zusammengeführt.
Hinweis: Die Ansicht users
muss im Join jetzt mit den Aliasnamen buyers
und sellers
referenziert werden.
Felder aus einem Join beschränken
Mit dem Parameter fields
können Sie angeben, welche Felder aus einem Join in einen Explore übernommen werden. Standardmäßig werden alle Felder aus einer Ansicht beim Verbinden hinzugefügt. Es ist jedoch denkbar, dass Sie nur einen Teil der Felder aufnehmen möchten.
Wenn Sie beispielsweise orders
mit order_items
zusammenführen, möchten Sie möglicherweise nur die Felder shipping
und tax
in die Zusammenführung einbeziehen:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [shipping, tax]
}
}
Sie können auch auf eine Gruppe von Feldern verweisen, z. B. [set_a*]
. Innerhalb einer Ansicht wird jeder Satz mit dem Parameter set
definiert. Angenommen, Sie haben die folgende Gruppe in der Ansicht orders
definiert:
set: orders_set {
fields: [created_date, shipping, tax]
}
Anschließend können wir wie folgt festlegen, dass nur diese drei Felder übernommen werden, wenn orders
mit order_items
verbunden wird:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [orders_set*]
}
}
Symmetrische Summen
Looker verwendet eine Funktion namens „symmetrische Summen“, um Aggregationen (wie Summen und Durchschnittswerte) auch dann richtig zu berechnen, wenn Joins zu einem Fanout führen. Symmetrische Summen werden unter Symmetrische Summen ausführlicher beschrieben. Das Fanout-Problem, das durch symmetrische Aggregate gelöst wird, wird im Community-Beitrag Das Problem von SQL-Fanouts erläutert.
Primärschlüssel erforderlich
Damit Messwerte (Aggregationen) über Joins erfolgen, müssen Sie in allen am Join beteiligten Ansichten Primärschlüssel definieren.
Dazu fügen Sie in jeder Ansicht den Parameter primary_key
zur Primärschlüssel-Felddefinition hinzu:
dimension: id {
type: number
primary_key: yes
}
Unterstützte SQL-Dialekte
Damit Looker symmetrische Summen in Ihrem Looker-Projekt unterstützen kann, müssen diese auch von Ihrem Datenbankdialekt unterstützt werden. In der folgenden Tabelle ist zu sehen, welche Dialekte symmetrische Summen in der aktuellen Looker-Version unterstützen:
Dialekt | Unterstützt? |
---|---|
Actian Avalanche | Ja |
Amazon Athena | Ja |
Amazon Aurora MySQL | Ja |
Amazon Redshift | Ja |
Amazon Redshift 2.1+ | Ja |
Amazon Redshift Serverless 2.1+ | Ja |
Apache Druid | Nein |
Apache Druid 0.13+ | Nein |
Apache Druid 0.18+ | Nein |
Apache Hive 2.3+ | Nein |
Apache Hive 3.1.2+ | Nein |
Apache Spark 3+ | Ja |
ClickHouse | Nein |
Cloudera Impala 3.1+ | Ja |
Cloudera Impala 3.1+ with Native Driver | Ja |
Cloudera Impala with Native Driver | Nein |
DataVirtuality | Ja |
Databricks | Ja |
Denodo 7 | Ja |
Denodo 8 & 9 | Ja |
Dremio | Nein |
Dremio 11+ | Ja |
Exasol | Ja |
Firebolt | Ja |
Google BigQuery Legacy SQL | Ja |
Google BigQuery Standard SQL | Ja |
Google Cloud PostgreSQL | Ja |
Google Cloud SQL | Ja |
Google Spanner | Ja |
Greenplum | Ja |
HyperSQL | Nein |
IBM Netezza | Ja |
MariaDB | Ja |
Microsoft Azure PostgreSQL | Ja |
Microsoft Azure SQL Database | Ja |
Microsoft Azure Synapse Analytics | Ja |
Microsoft SQL Server 2008+ | Ja |
Microsoft SQL Server 2012+ | Ja |
Microsoft SQL Server 2016 | Ja |
Microsoft SQL Server 2017+ | Ja |
MongoBI | Nein |
MySQL | Ja |
MySQL 8.0.12+ | Ja |
Oracle | Ja |
Oracle ADWC | Ja |
PostgreSQL 9.5+ | Ja |
PostgreSQL pre-9.5 | Ja |
PrestoDB | Ja |
PrestoSQL | Ja |
SAP HANA | Ja |
SAP HANA 2+ | Ja |
SingleStore | Ja |
SingleStore 7+ | Ja |
Snowflake | Ja |
Teradata | Ja |
Trino | Ja |
Vector | Ja |
Vertica | Ja |
Sollte Ihr Dialekt symmetrische Summen nicht unterstützen, müssen Sie bei der Ausführung von Joins in Looker besonders aufmerksam sein, da einige Arten von Joins zu fehlerhaften Aggregationen (wie Summen und Durchschnittswerte) führen können. Dieses Problem und die entsprechenden Workarounds werden im Communitybeitrag The problem of SQL fanouts ausführlich beschrieben.
Weitere Informationen zu Joins
Weitere Informationen zu Join-Parametern in LookML finden Sie in der Join-Referenz.