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 composer des requêtes SQL portant sur une base de données particulière.

LookML est un langage de dépendance, comme make, par opposition aux langages impératifs tels que C ou Ruby. LookML fournit des types de données et une syntaxe prédéfinis pour la modélisation des données. Vous n'avez pas besoin d'avoir de l'expérience avec les langages de programmation pour comprendre LookML. LookML est indépendant de divers dialectes SQL et encapsule des expressions SQL pour prendre en charge toute implémentation SQL.

LookML incite les analystes à ne pas se répéter (style DRY, Don't Repeat Yourself) et à n'écrire les expressions SQL qu'une seule fois, dans un seul endroit, afin que Looker puisse réutiliser indéfiniment le code pour générer des requêtes SQL ad hoc. Les utilisateurs métier peuvent ensuite utiliser les résultats pour créer des requêtes complexes dans Looker, en se concentrant sur le contenu dont ils ont besoin, et non sur les subtilité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 contrôlés par version via un dépôt Git. Les fichiers de modèle contiennent des informations sur les tables que le projet utilisera et sur la manière dont elles 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 gérer des modèles de données qui définissent la structure des données et les règles métier pour les données analysées. Le générateur SQL Looker traduit LookML en SQL, ce qui permet aux utilisateurs professionnels d'effectuer des requêtes sans écrire de code LookML ni 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, elle 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 leurs relations, consultez Termes et concepts LookML.

Ce que voient les utilisateurs

La configuration du projet et le contenu spécifique de ses fichiers déterminent ce que les utilisateurs voient et comment ils peuvent interagir avec Looker.

  1. Le panneau "Explorer" du panneau de navigation de gauche est organisé par nom de modèle. 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 la liste des champs disponibles dans les tables incluses dans cette vue. La plupart des vues affichent à la fois des dimensions et des 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 pivots dans le volet de sélection des 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 à la fois un tableau de données et une visualisation du prix de vente total et de la marge brute totale des commandes renvoyées au cours de l'année écoulé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

Le fait de savoir explorer des données dans Looker vous sera d'une aide précieuse 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 de SQL avant de vous plonger dans LookML

L'écriture de code LookML exige de comprendre les requêtes SQL. Nul besoin toutefois d'être un expert SQL, puisque même les débutants peuvent créer des modèles Looker performants. 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: