Présentation de LookML

LookML est l'acronyme de Looker Modeling Language. Il s'agit du langage utilisé par Looker pour créer des modèles de données sémantiques. Vous pouvez utiliser LookML pour décrire des dimensions, des agrégations, des calculs et des relations de données dans votre base de données SQL. Looker crée des requêtes SQL sur une base de données particulière à l'aide d'un modèle écrit en LookML.

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. La structure de la syntaxe LookML est claire et facile à apprendre. (Vous n'avez pas besoin d'avoir une expérience préalable des langages de programmation pour comprendre LookML. Tout ce que vous devez savoir est présenté ici.) LookML est indépendant de dialectes SQL spécifiques et encapsule les expressions SQL compatibles avec toutes les implémentations SQL.

Pour les analystes de données, LookML favorise le style DRY ("ne pas répéter") qui consiste à écrire des expressions SQL une fois, au même endroit, et que Looker utilise le code à plusieurs reprises pour générer des requêtes SQL ad hoc. Les utilisateurs professionnels peuvent ensuite utiliser ces 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 la complexité de la structure SQL.

Projets LookML

LookML est défini dans les projets. Un projet LookML est une collection de fichiers incluant au moins des fichiers de modèle et d'affichage, et éventuellement d'autres types de fichiers, généralement contrôlés ensemble par 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 manière dont elles doivent être jointes. Les fichiers de vue décrivent comment les informations sont calculées sur chaque table (ou dans 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).

Le schéma suivant illustre les éléments LookML fondamentaux d'un projet et leurs relations. Pour en savoir plus, consultez les 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 menu Explorer 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 effectuer une recherche dans le menu s'ils connaissent le nom de l'exploration qu'ils souhaitent.

  3. Les développeurs peuvent inclure des descriptions pour les explorations, qui s'affichent lorsque les utilisateurs passent la souris dessus. Cet exemple présente une exploration appelée Items de commande.

  4. Le volet Sélecteur de champs est organisé en fonction des noms 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 affichent des dimensions et des mesures. Cet exemple sélectionne une dimension Mois à partir d'un groupe de dimensions Date de retour, qui a été défini dans le fichier de vues.

  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 de l'outil 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. En exécutant cette exploration, vous générez une requête SQL qui renvoie à la fois un tableau de données et une visualisation du prix soldé total et de la marge brute totale des commandes renvoyées au cours de l'année précédente.

Exemple de code

L'exemple de code suivant illustre un projet LookML minimal pour une boutique d'e-commerce, qui comporte 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 de 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 les cours de Google Cloud Skills Boost.

Apprendre à utiliser Looker pour interroger et explorer les données

Savoir explorer les données dans Looker vous aidera à 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 suggérons les ressources suivantes:

Passez en revue les principes de base de SQL avant de vous intéresser à 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 :

Découvrir 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.

Une fois que vous avez appris les bases de LookML, consultez les pages suivantes: