Modèles LookML courants

Cette page décrit les modèles LookML courants suivants:

Attribution de libellés à des champs (et noms de l'interface utilisateur)

Looker convertit les noms de champs LookML en chaînes affichées par l'interface utilisateur en combinant le nom de la vue en police normale avec le nom court du champ en gras. Par exemple, un champ intitulé Montant dans la vue Commandes apparaîtrait dans l'interface utilisateur sous la forme Montant des commandes. Sur cette page, les noms des deux champs sont en gras et le nom de la vue commence par une majuscule (ORDERS Amount) pour clarifier la discussion.

Si vous souhaitez qu'un champ porte un nom différent du nom de sa colonne dans une table, modifiez le nom du champ et utilisez le paramètre sql pour associer le champ à la colonne appropriée dans la table. Dans l'exemple suivant, la table airports comporte une colonne cntrl_twr. Looker générerait la déclaration suivante :

view: airports {
  dimension: cntrl_twr {        # full name: airports.cntrl_twr
    type: yesno                 # default name: AIRPORT Cntrl Twr (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;  # the sql expression for this field
  }
}

Vous pouvez renommer la dimension cntrl_twr pour qu'elle soit plus lisible:

view: airports {
  dimension: has_control_tower {  # full name: airports.has_control_tower
    type: yesno                   # aliased name: AIRPORTS Has Control Tower (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;    # the sql expression for this field
  }
}

Filtrage de décomptes par dimension

Vous pouvez effectuer un regroupement par dimension et compter les entités. En regroupant les données par pays des utilisateurs, le nombre de commandes vous indiquera d'où proviennent vos commandes par pays. Cependant, il est souvent utile d'établir un décompte filtré par une valeur dimensionnelle. Par exemple, vous pouvez créer une mesure et la nommer ORDERS France Count:

view: users {
  dimension: country {}
}
view: orders {
  dimension: id {
    primary_key: yes
    sql: ${TABLE}.id ;;
  }
  measure: count {
    type: count
    drill_fields: [detail]
  }
  measure: france_count {
    type: count   # COUNT(CASE WHEN users.country = 'France' THEN 1 ELSE NULL END)
    filters: [users.country: "France"]
  }
}

Les filtres peuvent utiliser n'importe quelle expression. Si vous vouliez un champ établissant le décompte des utilisateurs de l'UE, vous pourriez utiliser une commande de ce type :

measure: eu_count {
  type: count   # COUNT(CASE WHEN users.countrycode IN 'UK','FR','ES' THEN 1 ELSE NULL END)
  drill_fields: [detail]
  filters: [users.countrycode: "UK,FR,ES"]
}

Si vous souhaitez filtrer avec une expression mathématique, veillez à la placer entre guillemets doubles:

measure: total_orders_above_100_dollars {
  type: sum   # SUM(CASE WHEN order.value > 100 THEN order.value ELSE NULL END)
  sql: ${order.value} ;;
  drill_fields: [detail]
  filters: [order.value: ">100"]
}

Pourcentages

De nombreux indicateurs clés de performance sont exprimés sous la forme de pourcentages, tels que « le pourcentage d'articles retournés », « le pourcentage d'e-mails ayant abouti à une vente » ou d'autres exemples de « le pourcentage de X que Y ». Dans LookML, le modèle de conception consiste à établir un décompte des deux conditions et à créer un troisième champ pour calculer le pourcentage des deux.

dimension: returned {
  type: yesno
}
measure: count {   # total count of items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
}
measure: returned_count {   # count of returned items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
  filters: [returned: "Yes"]
}
measure: percent_returned {
  type: number
  sql: 100.0 * ${returned_count} / NULLIF(${count}, 0) ;;
  value_format: "0.00"
}

Utilisez le format suivant pour calculer les pourcentages. Dans Postgres, les décomptes sont des entiers et la division d'entiers produit des entiers. Une multiplication par 100,0 convertit le premier décompte en nombre à virgule flottante, et la suite de l'expression est par conséquent convertie en nombre flottant. Pour éviter les erreurs de division par zéro, NULLIF(value, 0) convertit une valeur nulle en valeur nulle, ce qui rend le résultat nul et évite une erreur.

100.0 * ${returned_count} / NULLIF(${count}, 0)

Utilisation d'ensembles pour procéder à une exploration détaillée

L'une des fonctionnalités les plus puissantes de Looker consiste à pouvoir détailler des données pour visualiser les entités sous-jacentes qui composent un décompte ou une autre mesure.

Lorsque vous cliquez sur une mesure dans l'interface utilisateur, Looker crée une requête pour localiser l'ensemble de données qui compose la mesure. Chaque valeur de chaque dimension de la ligne du tableau est ajoutée

Pour afficher les détails, Looker a besoin d'une liste spécifique de champs d'analyse à afficher lorsque l'utilisateur clique sur la valeur de la mesure. Lorsque vous générez un modèle, le générateur crée généralement des champs d'analyse initiaux. auxquels vous pouvez ajouter les vôtres. Par exemple, supposons que vous mesurez le nombre de commandes selon l'état des comptes utilisateur au cours de la semaine précédente. Dans Looker, la requête ressemblerait à ceci:

USERS StateORDERS Count
Californie24
Texas5
Colorado4
Floride4
Illinois4

Si vous cliquez sur 24 dans la ligne Californie, vous pouvez vous attendre à voir les 24 commandes qui proviennent de Californie. Looker ajoute le filtre Utilisateurs État: Californie, mais ne sait pas quels champs vous souhaitez afficher dans l'ordre. Vous devez d'abord utiliser un ensemble pour déclarer ces champs dans votre modèle.

Dans LookML, un set est une liste de noms de champs (dimension, mesure et filtre). Vous utilisez des ensembles pour fournir à Looker les informations suivantes:

  • Champs que vous souhaitez afficher lorsque vous affichez le détail d'un décompte ou d'une autre mesure
  • Champs que vous souhaitez importer lorsque vous joignez une vue
  • Champs à indexer dans une exploration

Étant donné que le même ensemble peut être utilisé à plusieurs endroits dans un modèle, Looker propose plusieurs méthodes de création d'ensembles.

Ensembles littéraux

Un ensemble littéral est un moyen simple de définir un ensemble dans LookML, en particulier lorsque l'ensemble n'est utilisé qu'une seule fois. Un ensemble littéral est créé en déclarant l'ensemble en tant que tableau. Vous pouvez déclarer des ensembles littéraux à l'aide de [].

Prenons l'exemple suivant :

view: customers {
  dimension: id {
    primary_key: yes
  }
  measure: count {
    type: count
  }
  dimension: city {}
  dimension: state {}
  dimension: name {}
}

Dans cet exemple, les champs que vous souhaitez afficher sont id, name et city.

Dans la mesure, vous pouvez déclarer un tableau littéral comme suit:

measure: count {
  type: count
  drill_fields: [id, name, city]
}

Ensembles nommés

Supposons que deux nombres soient définis dans la vue customers: count et in_california_count. Lorsqu'un utilisateur détaille le champ Nombre ou Nombre en Californie dans une exploration, vous souhaitez afficher les champs id, name et city.

Dans un premier temps, déclarer ces champs littéralement peut sembler suffisant:

view: customers {
  measure: count {
    type: count
    drill_fields: [id, name, city]
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [id, name, city]
  }
}

Toutefois, si vous souhaitez ajouter un nouveau champ (tel que customers.state), vous devez modifier les deux listes, sauf si vous avez utilisé le paramètre set pour créer des ensembles nommés que vous pouvez gérer à un endroit et les utiliser à plusieurs endroits.

Le code suivant crée un ensemble customers.detail et pointe les deux décomptes vers le même ensemble de champs.

view: customers {
  set: detail {
    fields: [id, name, city]      # creates named set customers.detail
  }

  measure: count {
    type: count
    drill_fields: [detail*]       # show fields in the set "customers.detail"
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

Les ensembles LookML présentent les avantages suivants:

  • La redéclaration des ensembles est additive. Si vous déclarez un ensemble à plusieurs endroits, Looker inclut tous les champs déclarés pour l'ensemble dans tous les emplacements.
  • Vous pouvez intégrer des ensembles dans d'autres ensembles en saisissant le nom de l'autre ensemble suivi d'un astérisque, par exemple setname*.
  • Vous pouvez supprimer des éléments d'un ensemble en plaçant un trait d'union devant le nom du champ (par exemple, -fieldname).

Personnalisation d'une visualisation détaillée

Si votre administrateur Looker a activé la fonctionnalité de laboratoire Exploration visuelle, les visualisations d'analyse "Regarder" et "Explorer" ne sont pas toujours définies par défaut sur une table de données. Dans ce cas, vous pouvez personnaliser la visualisation affichée à l'aide de variables Liquid dans le paramètre link, comme indiqué sur la page de documentation du paramètre link et sur la page des bonnes pratiques Exploration des données plus puissante.

Les tableaux de bord acceptent une analyse visuelle à l'aide du paramètre link, sans qu'il soit nécessaire d'activer la fonctionnalité de laboratoire Analyse visuelle.

Filtrage de jeux de résultats

LookML propose différentes opérations de filtrage applicables aux champs et aux explorations pour filtrer les jeux de résultats avant qu'ils soient renvoyés à l'utilisateur.

always_filter sur l'exploration

Utilisez always_filter pour toujours appliquer un ensemble de filtres à toute requête exécutée dans une exploration. Les filtres apparaîtront dans l'interface utilisateur de Looker et, même si les utilisateurs peuvent modifier la valeur de filtre par défaut que vous fournissez, ils ne peuvent pas les supprimer. En général, ces filtres sont utilisés pour supprimer des données que vous ne souhaitez pas inclure en temps normal. Par exemple, supposons que vous souhaitiez n'afficher que les commandes terminées ou en attente dans l'exploration Commandes. Vous pouvez ajouter le code LookML suivant:

explore: orders {
  view_name: order
    filters: [status: "complete,pending"]
  }
}

Si l'utilisateur souhaite afficher les commandes avec d'autres valeurs d'état, il peut définir ORDERS Status (État des commandes) sur % dans l'interface utilisateur.

sql_always_where sur l'exploration

Si vous souhaitez appliquer une restriction de requête que les utilisateurs ne peuvent pas modifier, vous pouvez utiliser sql_always_where. Outre les requêtes exécutées par les humains, la restriction s'applique alors aux tableaux de bord, aux présentations planifiées et aux informations incorporées liées à cette exploration. Une condition sql_always_where n'est pas présentée à l'utilisateur, sauf s'il examine le code SQL sous-jacent des requêtes qu'il crée.

L'exemple qui suit empêche les utilisateurs de visualiser les commandes antérieures au 2012-01-01 :

# Using Looker references
explore: order {
  sql_always_where: ${created_date} >= '2012-01-01' ;;
}

# Using raw SQL
explore: order {
  sql_always_where: DATE(created_time) >= '2012-01-01' ;;
}

conditionally_filter sur l'exploration

L'interrogation de tables très volumineuses doit être mûrement réfléchie, car les requêtes illimitées peuvent rapidement devenir trop lourdes pour la base de données. LookML permet de résoudre ce problème avec conditionally_filter.

Vous utilisez le paramètre conditionally_filter pour appliquer un filtre à la requête, sauf si l'utilisateur a déjà ajouté un filtre pour l'un des champs répertoriés dans la section unless.

L'exemple suivant ne modifie pas la requête de l'utilisateur s'il a appliqué un filtre à un ou plusieurs de ces champs: created_date, shipped_time, shipped_date, orders.id ou customer.name. Si l'utilisateur n'a filtré aucun de ces champs, Looker ajoutera automatiquement un filtre d'un jour le orders.created_time.

  filters: [orders.created_time: "1 day"]
  unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}