Modèles LookML courants

Cette page décrit les modèles LookML 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 d'épaisseur standard avec le nom court du champ en gras. Par exemple, un champ intitulé Amount (Montant) dans la vue Orders (Commandes) apparaît dans l'interface utilisateur sous le nom Orders Amount (Montant des commandes). Sur cette page, les noms des deux champs sont en gras et le nom de la vue s'affiche en majuscules (ORDERS Amount) afin d'éclaircir la discussion.

Si vous souhaitez qu'un champ ait un nom différent de celui de sa colonne dans une table, modifiez le nom du champ et utilisez le paramètre sql pour l'associer à 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 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 regrouper les données par dimension et compter les entités. En regroupant par UTILISATEURS par pays, NOMBRE DE COMMANDES vous indiquera d'où viennent vos commandes par pays. Toutefois, il est souvent utile de calculer un décompte filtré en fonction d'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 des résultats à l'aide d'une expression mathématique, veillez à l'entourer de 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 forme de pourcentages, tels que « le pourcentage d'articles retournés », « le pourcentage d'e-mails qui ont abouti à une vente » ou d'autres instances de « 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 des 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 qu'une liste spécifique de champs d'analyse s'affiche 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 pour vous. auxquels vous pouvez ajouter les vôtres. Par exemple, supposons que vous mesurez le Nombre de commandes par l'état UTILISATEUR au cours de la semaine précédente. Dans Looker, la requête se présente comme suit:

USERS StateORDERS Count
Californie24
Texas5
Colorado4
Floride4
Illinois4

Si vous cliquez sur 24 dans la ligne Californie, vous devriez voir s'afficher les 24 commandes provenant de Californie. Bien que Looker ajoute le filtre UTILISATEURS État: Californie, Looker ne sait pas quels champs vous souhaitez afficher dans la commande. 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). Les ensembles vous permettent de fournir à Looker les informations suivantes:

  • Champs à afficher lorsque vous explorez un nombre ou une autre mesure en détail
  • 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 d'un modèle, Looker propose plusieurs méthodes pour créer des ensembles.

Ensembles littéraux

Un ensemble littéral est un moyen simple de définir un ensemble dans LookML, en particulier lorsqu'il 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 voulez 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 décomptes soient définis dans la vue customers: count et in_california_count. Lorsqu'un utilisateur affiche les détails du champ Nombre ou Nombre d'éléments en Californie dans une exploration, les champs id, name et city sont affichés.

Au départ, 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 champ (par exemple, 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 même endroit et utiliser à plusieurs endroits.

Le code suivant crée un ensemble customers.detail et renvoie 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 sont puissants pour les raisons suivantes:

  • La redéclaration d'ensembles est additive. Si vous déclarez un ensemble à plusieurs endroits, Looker inclut tous les champs qui ont été déclarés pour l'ensemble dans l'ensemble des 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 Analyse visuelle, les visualisations d'analyse de vue et d'exploration ne s'affichent pas toujours par défaut sur un tableau de données. Dans ce cas, vous pouvez personnaliser la visualisation affichée en utilisant des 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 concernant l'exploration de données plus performante.

Les tableaux de bord sont compatibles avec les analyses détaillées à l'aide du paramètre link, sans que vous ayez besoin d'activer la fonctionnalité Labs Analyse détaillée.

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 dans l'onglet "Explorer"

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, bien que les utilisateurs puissent modifier la valeur de filtre par défaut que vous fournissez, ils ne peuvent pas les supprimer. Généralement, ces filtres sont utilisés pour supprimer des données que vous ne souhaitez normalement pas inclure. Par exemple, supposons que dans l'exploration Commandes, vous souhaitiez uniquement voir les commandes terminées ou en attente. Vous pouvez ajouter le code LookML suivant:

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

Si l'utilisateur souhaite afficher les commandes associées à d'autres valeurs d'état, il peut définir ORDERS Status (État de la commande) sur % dans l'interface utilisateur.

sql_always_where dans l'onglet "Explorer"

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 consulte le 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 dans l'onglet "Explorer"

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 offre un moyen de résoudre ce problème sous la forme de conditionally_filter.

Le paramètre conditionally_filter permet d'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 n'apportera aucune modification à la requête de l'utilisateur si celui-ci 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 appliqué aucun filtre à l'un de ces champs, Looker ajoute 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]
}