Les jointures vous permettent de relier différentes vues. Vous pouvez ainsi explorer des données à partir de plusieurs vues à la fois et voir comment les différentes parties de vos données sont liées.
Par exemple, votre base de données peut inclure les tables order_items, orders et users. Il est possible d'utiliser des jointures pour explorer simultanément les données de toutes les tables. Cette page explique comment utiliser la fonction de jointure de LookML, notamment ses paramètres spécifiques et ses modèles de jointure.
Les jointures commencent par une exploration
Les jointures sont définies dans le fichier de modèle pour établir la relation entre une exploration et une vue. Elles relient une ou plusieurs vues d'une exploration, directement ou par le biais d'une autre vue jointe.
Prenons l'exemple de deux tables de base de données: order_items et orders. Après avoir généré des vues pour les deux tables, déclarez une ou plusieurs d'entre elles sous le paramètre explore dans le fichier de modèle:
explore: order_items { ... }
Lorsque vous exécutez une requête depuis la fonction order_items Explorer, order_items apparaît dans la clause FROM du code SQL généré:
SELECT ...
FROM order_items
Vous pouvez rejoindre notre order_items Explorer. Par exemple, pour ajouter des données sur le order dont fait partie order_item, vous pouvez procéder comme suit:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
Le code LookML ci-dessus a deux fonctions. Tout d'abord, l'interface utilisateur affiche les champs des champs orders et order_items:
Deuxièmement, le LookML explique comment joindre orders et order_items. Converti en SQL, ce code LookML se présenterait comme suit :
SELECT ...
FROM order_items
LEFT JOIN orders
ON order_items.order_id = orders.id
Ces paramètres LookML sont décrits plus en détail dans les sections suivantes. Consultez la page de référence des paramètres join pour en savoir plus sur la traduction de ce LookML en SQL.
Conseil de l'équipe Chat : les utilisateurs posent la plupart des questions sur l'erreur de validation, le champ "Inconnu ou inaccessible", ce qui peut être dû à une jointure manquante. Pour en savoir plus, consultez cet article du Centre d'aide.
Paramètres de jointure
Quatre principaux paramètres sont utilisés : joins, join, type, relationship et sql_on.
Étape n° 1 : Début de l'exploration
Commencez par créer la section order_items Explorer:
explore: order_items { ... }
Étape 2 : join
Pour joindre une table, vous devez tout d'abord la déclarer dans une vue. Dans cet exemple, orders est une vue existante de notre modèle.
Ensuite, utilisez le paramètre join pour déclarer que vous souhaitez joindre la vue orders à order_items:
explore: order_items {
join: orders { ... }
}
Étape 3: type
Réfléchissez à la type de jointure à effectuer. Looker est compatible avec LEFT JOIN, INNER JOIN, FULL OUTER JOIN et CROSS JOIN. Elles correspondent aux valeurs des paramètres type de left_outer, inner, full_outer et cross.
explore: order_items {
join: orders {
type: left_outer
}
}
La valeur par défaut de type est left_outer, et correspond généralement au type de jointure le plus courant.
Étape 4 : relationship
Définissez une jointure relationship entre order_items et orders. Il est important de déclarer correctement les relationship d'une jointure pour que Looker puisse calculer des mesures précises. La relation est définie de la order_items Explorer à la vue orders. Les options possibles sont one_to_one, many_to_one, one_to_many et many_to_many.
Dans cet exemple, il peut y avoir plusieurs order_items pour un seul order. La relation entre order_items et orders est many_to_one :
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
}
}
Si vous n'incluez pas de relationship dans votre jointure, Looker est défini par défaut sur many_to_one.
Pour obtenir des conseils supplémentaires sur la définition correcte du paramètre relationship pour une jointure, consultez l'article Utiliser le paramètre relationship correctement.
Étape 5: sql_on
Déclarez comment joindre ces deux tables avec le paramètre sql_on ou foreign_key. Nous recommandons généralement sql_on, car il offre les mêmes possibilités que foreign_key, mais il est généralement plus facile à comprendre.
sql_on équivaut à la clause ON dans le code SQL généré pour une requête. Avec ce paramètre, vous pouvez désigner les champs à rapprocher pour effectuer la jointure :
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
Vous pouvez également écrire des jointures plus complexes. Par exemple, vous pouvez choisir de ne joindre que les campagnes dont la valeur id est supérieure à 1 000:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} AND ${orders.id} > 1000 ;;
}
}
Consultez les opérateurs de substitution pour en savoir plus sur la syntaxe ${ ... } dans ces exemples.
Étape n° 6 : Test
Vérifiez que cette jointure fonctionne comme prévu en accédant à l'onglet Explorer les articles. Vous devriez voir des champs de order_items et de orders.
Pour en savoir plus sur le test des modifications de LookML, consultez la section Développement de modèles.
Jointure via une autre vue
Vous pouvez joindre une vue à une exploration par le biais d'une autre vue. Dans l'exemple ci-dessus, vous avez joint orders à order_items via le champ order_id. Nous souhaitons également joindre les données d'une vue appelée users à la fonction order_items Explorer, même s'ils ne partagent pas de champ commun. Pour ce faire, connectez-vous via la vue orders.
Utilisez sql_on ou foreign_key pour joindre users à orders au lieu de order_items. Pour ce faire, définissez correctement le champ orders pour orders.user_id.
Voici un exemple utilisant 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} ;;
}
}
Jointures multiples d'une vue
Une vue users contient des données pour les acheteurs et les vendeurs. Pour associer les données de cette vue à order_items, mais séparément pour les acheteurs et les vendeurs, vous pouvez associer users deux fois, avec des noms différents, à l'aide du paramètre from.
Le paramètre from vous permet de spécifier la vue à utiliser dans une jointure, tout en lui donnant un nom unique. Exemple :
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} ;;
}
}
Dans ce cas, seules les données des acheteurs sont associées sous la forme buyers, tandis que seules les données des vendeurs sont associées sous la forme sellers.
Remarque : La vue users doit maintenant être désignée par les alias buyers et sellers de la jointure.
Limitation des champs d'une jointure
Le paramètre fields vous permet de spécifier les champs importés d'une jointure dans une exploration. Par défaut, en cas de jointure, tous les champs d'une vue sont pris en compte. Il arrive toutefois qu'un sous-ensemble de champs soit suffisant.
Par exemple, lorsque orders est joint à order_items, vous pouvez utiliser uniquement les champs shipping et tax via la jointure:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [shipping, tax]
}
}
Vous pouvez également référencer un ensemble de champs, par exemple [set_a*]. Chaque ensemble est défini dans une vue à l'aide du paramètre set. Supposons que l'ensemble suivant soit défini dans la vue orders:
set: orders_set {
fields: [created_date, shipping, tax]
}
Vous pouvez choisir de n'afficher que ces trois champs lorsque vous rejoignez orders dans order_items:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [orders_set*]
}
}
Agrégations symétriques
Looker utilise une fonction appelée "agrégats symétriques" pour calculer correctement les agrégations (comme les sommes et les moyennes), même lorsque les jointures entraînent une distribution ramifiée. Les agrégations symétriques sont décrites plus en détail dans l'article du centre d'aide intitulé Une explication simple des agrégations symétriques, et le problème qu'elles résolvent est expliqué dans l'article The problème of SQL fanouts (Le problème des distributions SQL).
Clés primaires requises
Pour que les mesures (agrégations) soient conservées dans une jointure, vous devez définir des clés primaires dans toutes les vues impliquées dans la jointure.
Pour ce faire, ajoutez le paramètre primary_key à la définition du champ de clé primaire dans chaque vue:
dimension: id {
type: number
primary_key: yes
}
Pour traiter correctement les mesures jointes, Looker compte su vous pour définir une clé primaire avec des valeurs non NULLES parfaitement uniques. Si vos données ne contiennent pas de clé primaire, déterminez si la concaténation de plusieurs champs générerait une clé primaire de valeurs complètement uniques et non nulles. Si votre clé primaire n'est pas unique ou contient des valeurs NULL et que votre requête inclut des données révélant ces problèmes, Looker renvoie une erreur, comme décrit dans cet article du Centre d'aide.
Dialectes SQL pris en charge
Pour que Looker prenne en charge les agrégations symétriques dans votre projet, votre dialecte de base de données doit également les prendre en charge. Le tableau suivant indique les dialectes compatibles avec les agrégations symétriques dans la dernière version de Looker:
Si votre dialecte ne reconnaît pas les agrégations symétriques, soyez attentif lors de l'exécution de jointures dans Looker, car certains types de jointures peuvent se solder par des agrégations (sommes, moyennes, etc.) inexactes. Ce problème et les solutions de contournement sont décrits en détail dans l'article du centre d'aide intitulé Le problème des distributions SQL.
En savoir plus sur les jointures
Pour en savoir plus sur les paramètres de jointure dans LookML, consultez la documentation de référence sur les jointures.