Présentation de LookML

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.

  1. Dans le panneau de navigation de gauche, le panneau "Explorer" est organisé par noms de model. Sous chaque nom de modèle se trouve une liste des explorations disponibles définies dans ce modèle.
  2. Les utilisateurs peuvent rechercher une exploration spécifique.

  3. Les développeurs peuvent définir des descriptions d'explorations que les utilisateurs peuvent consulter en pointant sur leur nom dans le menu Explorer.

  4. 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.

  5. Les utilisateurs peuvent sélectionner plusieurs mesures sur lesquelles baser la requête.

  6. Les utilisateurs peuvent appliquer des options telles que des filtres et des tableaux croisés dynamiques dans le volet du sélecteur de champs.

  7. Les utilisateurs peuvent affiner les termes de la requête.

  8. Les utilisateurs peuvent choisir un type de visualisation à appliquer aux résultats de la requête.

  9. 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é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:

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 :

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.

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: