LookML, l'abréviation de Looker Modeling Language, est le langage utilisé dans Looker pour créer des modèles de données sémantiques. Vous pouvez utiliser LookML pour décrire les dimensions, les agrégations, les calculs et les relations entre les données de votre base de données SQL. Looker utilise un modèle écrit en LookML pour construire des requêtes SQL sur une base de données particulière.
LookML est un langage de dépendance comme make, par opposition à un langage impératif comme C ou Ruby. LookML fournit des types de données et une syntaxe prédéfinis pour la modélisation des données. Aucune expérience préalable des langages de programmation n'est nécessaire pour comprendre LookML. LookML est indépendant de divers dialectes SQL et encapsule des expressions SQL pour prendre en charge toute implémentation SQL.
Pour les analystes de données, LookML favorise le style DRY ("Ne vous répétez pas"), ce qui signifie que vous écrivez les expressions SQL une seule fois, au même endroit,et que Looker utilise le code de façon répétée pour générer des requêtes SQL ad hoc. Les utilisateurs professionnels peuvent ensuite utiliser les résultats pour créer des requêtes complexes dans Looker, en se concentrant uniquement sur le contenu dont ils ont besoin, et non sur les complexités de la structure SQL.
Projets LookML
LookML est défini dans des projets. Un projet LookML est un ensemble de fichiers comprenant au moins des fichiers de modèle et de vue, et éventuellement d'autres types de fichiers, qui sont généralement soumis à un contrôle des versions via un dépôt Git. Les fichiers de modèle contiennent des informations sur les tables qui seront utilisées par le projet et sur la façon dont ces tables doivent être jointes. Les fichiers de vue décrivent comment les informations sont calculées pour chaque table (ou pour plusieurs tables si les jointures le permettent).
LookML sépare la structure du contenu, de sorte que la structure des requêtes (la manière dont les tables sont jointes) est indépendante de leur contenu (les colonnes auxquelles accéder, les champs dérivés, les fonctions d'agrégation à calculer et les expressions de filtrage à appliquer).
Les requêtes Looker sont basées sur des fichiers de projet LookML. Les analystes de données utilisent LookML pour créer et maintenir des modèles de données qui définissent la structure des données et les règles commerciales pour les données analysées. Le générateur SQL de Looker traduit LookML en SQL, ce qui permet aux utilisateurs professionnels d'effectuer des requêtes sans écrire de code LookML ou SQL.
Les utilisateurs professionnels utilisent le générateur de requêtes Looker, ou l'interface Explorer, pour créer des requêtes basées sur le modèle de données défini par les analystes Looker. Les utilisateurs peuvent sélectionner des dimensions, des mesures et des filtres pour créer des requêtes personnalisées basées sur leurs propres questions et pour générer leurs propres insights.
Lorsqu'un utilisateur crée une requête, celle-ci est envoyée au générateur SQL de Looker, qui la traduit en SQL. La requête SQL est exécutée sur la base de données, puis Looker renvoie les résultats mis en forme à l'utilisateur dans l'interface d'exploration. L'utilisateur peut ensuite visualiser les résultats et générer des insights.
Pour en savoir plus sur les éléments LookML fondamentaux d'un projet et leur relation les uns avec les autres, consultez la section Termes et concepts LookML.
Ce que voient les utilisateurs
La façon dont le projet est configuré et le contenu spécifique de ses fichiers déterminent ce que les utilisateurs voient et comment ils peuvent interagir avec Looker.
- Dans le panneau de navigation de gauche, le panneau "Explorer" est organisé par noms de modèles. Sous chaque nom de modèle se trouve une liste des explorations disponibles définies dans ce modèle.
- Les utilisateurs peuvent rechercher une exploration spécifique.
Les développeurs peuvent définir des descriptions d'explorations que les utilisateurs peuvent consulter en pointant sur leur nom dans le menu Explorer.
Le volet du sélecteur de champs est organisé par noms de vues. Sous chaque nom de vue se trouve une liste des champs disponibles dans les tables incluses dans cette vue. La plupart des vues affichent à la fois les dimensions et les mesures. Cet exemple sélectionne une dimension Mois dans un groupe de dimensions Date de retour, qui a été défini dans le fichier de vue.
Les utilisateurs peuvent sélectionner plusieurs mesures sur lesquelles baser la requête.
Les utilisateurs peuvent appliquer des options telles que des filtres et des tableaux croisés dynamiques dans le volet du sélecteur de champs.
Les utilisateurs peuvent affiner les termes de la requête.
Les utilisateurs peuvent choisir un type de visualisation à appliquer aux résultats de la requête.
L'exécution de cette exploration génère une requête SQL qui renvoie un tableau de données et une visualisation du prix de vente total et de la marge brute totale des commandes retournées l'année passée.
Exemple de code
L'exemple de code suivant montre un projet LookML minimal pour une boutique en ligne, comportant un fichier de modèle (ecommercestore.model.lkml
) et deux fichiers de vue (orders.view.lkml
et customers.view.lkml
) :
######################################
# FILE: ecommercestore.model.lkml #
# Define the explores and join logic #
######################################
connection: order_database
include: "*.view.lkml"
explore: orders {
join: customers {
sql_on: ${orders.customer_id} = ${customers.id} ;;
}
}
##########################################################
# FILE: orders.view.lkml #
# Define the dimensions and measures for the ORDERS view #
##########################################################
view: orders {
dimension: id {
primary_key: yes
type: number
sql: ${TABLE}.id ;;
}
dimension: customer_id { # field: orders.customer_id
sql: ${TABLE}.customer_id ;;
}
dimension: amount { # field: orders.amount
type: number
value_format: "0.00"
sql: ${TABLE}.amount ;;
}
dimension_group: created { # generates fields:
type: time # orders.created_time, orders.created_date
timeframes: [time, date, week, month] # orders.created_week, orders.created_month
sql: ${TABLE}.created_at ;;
}
measure: count { # field: orders.count
type: count # creates a sql COUNT(*)
drill_fields: [drill_set*] # list of fields to show when someone clicks 'ORDERS Count'
}
measure: total_amount {
type: sum
sql: ${amount} ;;
}
set: drill_set {
fields: [id, created_time, customers.name, amount]
}
}
#############################################################
# FILE: customers.view.lkml #
# Define the dimensions and measures for the CUSTOMERS view #
#############################################################
view: customers {
dimension: id {
primary_key: yes
type: number
sql: ${TABLE}.id ;;
}
dimension: city { # field: customers.city
sql: ${TABLE}.city ;;
}
dimension: state { # field: customers.state
sql: ${TABLE}.state ;;
}
dimension: name {
sql: CONCAT(${TABLE}.firstname, " ", ${TABLE}.lastname) ;;
}
measure: count { # field: customers.count
type: count # creates a sql COUNT(*)
drill_fields: [drill_set*] # fields to show when someone clicks 'CUSTOMERS Count'
}
set: drill_set { # set: customers.drill_set
fields: [id, state, orders.count] # list of fields to show when someone clicks 'CUSTOMERS Count'
}
}
Autres ressources
Si vous débutez dans le développement LookML, envisagez d'utiliser les ressources décrites dans les sections suivantes pour accélérer votre apprentissage:
- Accéder à l'environnement d'apprentissage de Looker
- Découvrez comment utiliser Looker pour interroger et explorer des données.
- Revoyez les principes de base de SQL avant de vous plonger dans LookML
- Découvrez les principes de base de LookML
Accédez à l'environnement d'apprentissage de Looker
Découvrez les cours sur Google Cloud Skills Boost.
Découvrez comment utiliser Looker pour interroger et explorer des données
Savoir explorer des données dans Looker vous sera d'une grande utilité pour modéliser vos données dans LookML. Si vous ne savez pas comment utiliser Looker pour interroger, filtrer et explorer des données, nous vous conseillons les ressources suivantes:
- Commencez par les tutoriels Récupérer des données et les représenter dans des graphiques. Les liens au bas de chaque page vous guideront à travers les principales fonctionnalités de Looker.
- La quête de développement de compétences en analyse et visualisation de données dans Looker vous présentera les bases de l'exploration.
Revoyez les principes de base du langage SQL avant de vous plonger dans LookML
L'écriture de code LookML exige de comprendre les requêtes SQL. Nul besoin d'être un expert en SQL, et même les débutants peuvent créer de puissants modèles Looker. De solides connaissances en SQL constituent néanmoins un avantage pour tirer le meilleur parti de LookML.
Si une remise à niveau SQL s'impose, voici quelques-unes de nos ressources préférées :
- Tutoriels SQL interactifs pour suivre les cours SQL de la Kan Academy
- Tutoriels SQL interactifs SQLZoo
- Livre Sams Teach Yourself SQL in 10 Minutes de Ben Forta
Découvrez les principes de base de LookML
Ces ressources accélèreront votre acquisition de connaissances LookML. Servez-vous de votre compte de formation pour tester différents modèles de conception.
- Commencez par les termes et concepts LookML.
- Passez à la section Comment Looker génère le code SQL et Concepts LookML avancés.
- Une fois que vous maîtrisez LookML et SQL, renseignez-vous sur nos fonctionnalités plus avancées telles que les tables dérivées et les filtres modélisés.
Après avoir appris les bases de LookML, consultez les pages suivantes pour obtenir une présentation des différents types de paramètres LookML:
- Paramètres du modèle
- Explorer les paramètres
- Paramètres de jointure
- Paramètres de la vue
- Paramètres des champs
- Paramètres du tableau de bord