LookML est un langage permettant de décrire des dimensions, des agrégations, des calculs et des relations entre les données d'une 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.
Projets LookML
Un projet LookML est un ensemble de fichiers de modèle, de vue et de tableau de bord dont les versions sont généralement contrôlées via un référentiel Git. Les fichiers de modèle contiennent des informations sur les tables à utiliser et la manière de les joindre. Les fichiers de vue contiennent des informations sur la façon de calculer des donné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).
Requêtes SQL générées par Looker
Pour les analystes de données, LookML favorise le style DRY (ne le répétez pas), ce qui signifie que vous écrivez des expressions SQL une seule fois, au même endroit,et que Looker utilise le code à plusieurs reprises pour générer des requêtes SQL ad hoc. Pour les utilisateurs métier, le résultat final consiste à pouvoir 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.
L'illustration suivante présente une requête créée dans Looker qui joint les valeurs de plusieurs tables (Orders Items, Products, et Users) :
Dans la figure ci-dessus, l'utilisateur final n'a pas besoin de comprendre les expressions SQL pour les jointures ou le filtrage.
Un langage de dépendance pour décrire des structures de données
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. La structure de la syntaxe LookML est claire et facile à apprendre. (Vous n'avez pas besoin d'être expérimenté dans les langages de programmation. Tout ce que vous devez savoir est documenté ici.) 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.
Exemple de code
L'exemple ci-dessous montre un projet LookML minimal pour un site marchand, avec un fichier de modèle et deux fichiers de vue :
######################################
# 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'
}
}
LookML est sensible à la casse
LookML est sensible à la casse, vérifiez donc la casse lorsque vous mentionnez des éléments LookML. Looker vous avertit si vous avez fait référence à un élément qui n'existe pas. Dans l'exemple ci-dessous, le développeur a mal orthographié "Flights". L'IDE Looker affiche un avertissement indiquant que e_FLIGHTS_pdt n'existe pas. De plus, l'IDE suggère le nom d'une exploration existante, à savoir e_flights_pdt:
Toutefois, si votre projet contenait à la fois e_FLIGHTS_pdt et e_flights_pdt, l'IDE Looker ne pourrait pas vous corriger. Vous devez donc vous assurer de la version souhaitée. En règle générale, nous vous conseillons de respecter la casse pour les noms d'objets LookML.
Les noms des dossiers IDE sont également sensibles à la casse. Vous devez vérifier la casse du nom des fichiers dès que vous spécifiez des chemins de fichier. Par exemple, si vous avez un dossier nommé Views, vous devez utiliser la même casse dans le paramètre include. Là encore, l'IDE Looker signale une erreur si l'utilisation de minuscules/majuscules ne correspond pas à un dossier existant dans votre projet:
Présentation des éléments LookML fondamentaux
Le diagramme suivant illustre les éléments LookML fondamentaux et leurs relations. Pour en savoir plus, consultez Termes et concepts de LookML.
