Présentation de LookML

LookML, 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 dans 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.

Par opposition aux langages impératifs tels que C ou Ruby, LookML est un langage de dépendance, au même titre que make. 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 déjà utilisé des langages de programmation pour comprendre LookML. LookML ne dépend d'aucun dialecte SQL spécifique et encapsule des expressions SQL pour prendre en charge n'importe quelle 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

Le 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, dont les versions sont généralement contrôlées ensemble 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 de les joindre. 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 de Looker traduit le 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 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 Explorer. 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 sur la façon dont ils sont liés les uns aux autres, 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 noms de modèles. Sous chaque nom de modèle figure la 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 pour les explorations. Les utilisateurs peuvent les consulter en pointant sur le nom de l'exploration dans le menu Explorer.

  4. Le volet Sélecteur de champs est organisé par nom de vue. Sous chaque nom de vue se trouve la liste des champs disponibles à partir des 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 tableaux croisés dynamiques dans le volet du sélecteur de champ.

  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 un site marchand, avec 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 Looker

Consultez les cours sur Google Cloud Skills Boost.

Apprendre à utiliser Looker pour rechercher 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 n'avez pas l'habitude d'utiliser Looker pour interroger, filtrer et détailler des données, voici quelques ressources utiles :

Revoir les principes de base de SQL avant de se 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 :

Apprendre les fondamentaux 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 principes de base de LookML, consultez les pages suivantes pour obtenir des aperçus des différents types de paramètres LookML :