Introduction à LookML

LookML (pour 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 des dimensions, des agrégats, des calculs et des relations entre les données dans votre base de données SQL. Looker utilise un modèle écrit en LookML pour construire des requêtes SQL portant sur une base de données particulière.

LookML est un langage de dépendance tel que 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. Vous n'avez pas besoin d'expérience préalable en langage de programmation pour comprendre LookML. LookML est indépendant de certains 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 des expressions SQL une seule fois, au même endroit,et Looker utilise le code à plusieurs reprises pour générer des requêtes SQL ad hoc. Les utilisateurs métiers 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 en projects. 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 dont elles doivent être jointes. Les fichiers de vue décrivent comment les informations sont calculées sur chaque table (ou sur 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 métier des données en cours d'analyse. Le générateur SQL Looker traduit LookML en SQL, ce qui permet aux utilisateurs professionnels d'effectuer des requêtes sans avoir à é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 générer leurs propres insights.

Lorsqu'un utilisateur crée une requête, celle-ci est envoyée au générateur SQL Looker, qui la convertit 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 alors visualiser les résultats et générer des insights.

Pour en savoir plus sur les éléments LookML fondamentaux d'un projet et la façon dont ils sont liés les uns aux autres, consultez la section 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 la manière dont ils peuvent interagir avec Looker.

  1. Le panneau "Explorer" du panneau de navigation de gauche est organisé par nom de model. Sous chaque nom de modèle se trouve une liste des explorations disponibles définies dans le modèle en question.
  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 afficher en pointant sur le nom de l'exploration dans le menu Explore (Explorer).

  4. Le volet du sélecteur de champs est organisé par nom de vue. Sous chaque nom de vue se trouve une liste des champs disponibles dans les tables incluses dans cette vue. La plupart des vues indiquent à la fois les dimensions et les mesures. Cet exemple sélectionne une dimension Mois au sein d'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 à la fois une table de données et une visualisation du prix de vente total et de la marge brute totale des commandes retournées de l'année passée.

Exemple de code

L'exemple de code suivant montre un projet LookML minimal pour une boutique en ligne, qui contient 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 en 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

Consultez les cours sur Google Cloud Skills Boost.

Apprenez à utiliser Looker pour interroger et explorer des données

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 analyser des données, nous vous suggérons les ressources suivantes:

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. Vous n'avez pas besoin d'être un expert en SQL, et même les débutants peuvent créer des modèles Looker puissants. 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 bases 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.

Une fois que vous avez appris les bases de LookML, consultez les pages suivantes pour avoir un aperçu des différents types de paramètres LookML: