Améliorations de LookML

Présentation

Les améliorations LookML vous permettent d'adapter une vue ou une exploration existante sans modifier le fichier LookML qui la contient. C'est l'option idéale pour:

Par exemple, si le fichier de vue suivant est présent dans votre projet:

view: flights {
  sql_table_name: flightstats.accidents ;;

  dimension: id {
    label: "id"
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
}

Vous pouvez affiner la vue flights comme illustré dans l'exemple suivant: utilisez le paramètre view avec le même nom de vue, mais ajoutez un signe plus (+) devant le nom pour indiquer qu'il s'agit d'un affinement d'une vue existante.

Cet affinement ajoute une dimension air_carrier à la vue flights existante:

view: +flights {
  dimension: air_carrier {
    type: string
    sql: ${TABLE}.air_carrier ;;
  }
 }

Cet affinement peut se trouver dans n'importe quel fichier LookML du projet, comme un fichier de modèle, un fichier de vue ou dans son propre fichier LookML dédié. Pour en savoir plus, consultez la section Utiliser des perfectionnements dans votre projet LookML.

Le raffinement combiné au code LookML d'origine donne le résultat final comme s'il s'agissait du code LookML d'origine de la vue:

view: flights {
  sql_table_name: flightstats.accidents ;;

  dimension: id {
    label: "id"
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }

  dimension: air_carrier {
    type: string
    sql: ${TABLE}.air_carrier ;;
  }
}

Dans l'interface utilisateur de Looker, les utilisateurs verront la dimension Compagnie aérienne, comme si vous l'aviez ajoutée au fichier de vue d'origine.

Pour en savoir plus sur l'implémentation, consultez la section Exemple.

Améliorations par rapport aux extensions

Looker permet également d'étendre les objets LookML. L'extension est utile lorsque vous souhaitez créer une copie d'une vue ou d'une exploration existante afin d'y ajouter de nouveaux objets. Par exemple, vous pouvez créer une vue de base qui définit tous vos champs, puis plusieurs vues qui l'étendent. Vous pouvez ensuite modifier ces nouvelles vues pour masquer certains champs dans la vue de base, ou pour modifier les définitions ou les libellés des champs de la vue de base.

Les raffinements sont utiles lorsque vous souhaitez modifier une vue ou une exploration existante en ajustant certains objets, mais que vous ne souhaitez pas créer de copies de la vue ou de l'exploration. Les raffinements sont idéaux lorsque vous ne pouvez pas ou ne souhaitez pas modifier la vue de base ou l'exploration, ou lorsque la création d'une vue ou d'une exploration nécessiterait d'apporter des modifications importantes à d'autres références LookML. Pour voir un exemple de ce cas d'utilisation, consultez la section Exemple de cette page.

Dans la plupart des cas, les raffinements constituent une alternative plus simple et plus claire à extends.

Les développeurs LookML avancés peuvent utiliser le paramètre extends dans un affinement LookML. Pour en savoir plus, consultez la section Les raffinements peuvent contenir des extensions sur cette page.

Les raffinements remplacent la plupart des paramètres

Notez que, dans la plupart des cas, un affinement remplace les paramètres d'origine d'un objet. Dans l'exemple suivant, la vue d'origine comporte une dimension masquée (hidden: yes):

view: faa_flights {
  dimension: carrier {
    hidden: yes
  }
}

Dans un autre fichier, cette dimension est affinée avec hidden: no:


include: "/views/faa_flights.view.lkml"

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

Le dernier affinement a la priorité. hidden: no est donc appliqué et la dimension s'affiche dans la vue finale.

Dans certains cas, les raffinements sont cumulatifs au lieu de remplacer les paramètres. Pour en savoir plus, consultez la section Certains paramètres sont cumulatifs de cette page.

Certains paramètres sont additifs

Dans de nombreux cas, si l'affinage contient le même paramètre que l'objet affiné, il remplace les valeurs de paramètre de l'objet affiné.

Toutefois, les raffinements peuvent être additifs pour certains paramètres, ce qui signifie que les valeurs de l'objet de base sont utilisées conjointement avec celles de l'objet affiné.

Les paramètres suivants sont additifs:

Par exemple, voici une vue avec une dimension name avec un paramètre link:

view: carriers {
  sql_table_name: flightstats.carriers ;;

  dimension: name {
    sql: ${TABLE}.name ;;
    type: string
    link: {
      label: "Google {{ value }}"
      url: "http://www.google.com/search?q={{ value }}"
      icon_url: "http://google.com/favicon.ico"
    }
  }
}

Voici un affinement de la vue carriers, avec une dimension name qui présente différentes valeurs pour le paramètre link:


include: "/views/carriers.view.lkml"

view: +carriers {
  label: "Refined carriers"

  dimension: name {
    sql: ${TABLE}.name ;;
    type: string
    link: {
      label: "Dashboard for {{ value }}"
      url: "https://docsexamples.dev.looker.com/dashboards/307?Carrier={{ value }}"
      icon_url: "https://www.looker.com/favicon.ico"
    }
  }
}

Dans la vue carriers affinée, les deux paramètres link sont additifs. La dimension name affiche donc les deux liens.

Les améliorations sont appliquées dans l'ordre

Un objet peut être affiné plusieurs fois et à plusieurs endroits, ce qui permet aux développeurs Looker d'utiliser les affinages de manière très créative. Cela signifie également que les développeurs doivent être très attentifs à l'ordre dans lequel les améliorations sont appliquées:

  • Dans un projet, les raffinements sont appliqués dans l'ordre dans lequel leurs fichiers sont inclus. Les raffinements des fichiers inclus en dernier remplacent les raffinements des fichiers inclus précédemment.
  • Dans un même fichier, les améliorations sont appliquées ligne par ligne, de haut en bas. Les raffinements avec le numéro de ligne le plus élevé sont appliqués en dernier et remplacent les raffinements précédents, en cas de conflit.

Par exemple, le fichier de vue suivant contient deux améliorations de la vue faa_flights. Le premier affinement masque une dimension (hidden: yes), et le second affiche la dimension (hidden: no). En cas de conflit de ce type, l'affinement le plus bas dans le fichier prévaut : 

include: "//e_faa_original/views/faa_flights.view.lkml"

view: +faa_flights {
  dimension: carrier {
    hidden: yes
  }
}

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

La logique est similaire pour inclure plusieurs fichiers dans un projet: les améliorations du dernier fichier listé dans les inclusions ont la priorité. Par exemple, si un fichier de modèle inclut les fichiers suivants:

include: "/refinements/distance_analysis.lkml"
include: "/refinements/finishing_touches.lkml"

Les améliorations apportées au fichier distance_analysis.lkml sont appliquées en premier, puis celles du fichier finishing_touches.lkml. En cas de conflit, les améliorations du dernier fichier, finishing_touches.lkml, prévalent.

Utiliser final: yes pour empêcher d'autres affinements

Comme décrit précédemment, un même objet peut être affiné plusieurs fois à plusieurs endroits, et le dernier affinement remplace tous les affinements précédents.

Si vous souhaitez qu'un affinement soit considéré comme l'affinement final pour la vue ou l'exploration, vous pouvez ajouter l'indicateur final: yes à l'affinement. L'IDE Looker renvoie une erreur LookML si des perfectionnements existants sont appliqués après ce dernier perfectionnement ou si un développeur tente d'ajouter un nouveau perfectionnement qui serait appliqué après ce dernier perfectionnement. Par exemple, le deuxième affinement de ce fichier de vue générerait une erreur LookML, car l'affinement précédent comporte l'indicateur final: yes:

include: "//e_faa_original/views/faa_flights.view.lkml"

view: +faa_flights {
  final: yes
  dimension: carrier {
    hidden: yes
  }
}

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

Ajouter l'indicateur final: yes à un affinement est un bon moyen de vérifier que vos affinements sont appliqués dans l'ordre prévu.

Les raffinements peuvent contenir des extensions

Les développeurs LookML avancés peuvent utiliser un paramètre extends dans un perfectionnement LookML, ce qui ajoute l'objet étendu à l'objet en cours de perfectionnement.

Pour résumer le comportement de extends et les améliorations:

  • L'extension d'un objet crée une copie de l'objet, puis s'appuie sur celle-ci. Par exemple, vous pouvez créer une vue de base qui définit tous vos champs, puis plusieurs vues qui l'étendent. Chacune de ces nouvelles vues intègre une copie de la vue de base. À partir de là, un développeur peut ajouter différents champs, filtres ou autres propriétés pour modifier le contenu de la vue de base. L'idée est de commencer par un objet de base, puis de l'utiliser de différentes manières dans plusieurs autres objets. (Pour en savoir plus sur l'utilisation des extends, consultez la page de documentation Réutiliser du code avec extends.)
  • Le raffinage d'un objet ajoute une couche de modifications à l'objet, mais contrairement à l'extension, il ne crée pas plusieurs copies de l'objet. L'idée est de créer un objet de base sans modifier son code LookML d'origine.

Voici un exemple d'utilisation standard des raffinements : une exploration appelée orders et l'exploration +orders qui la raffine :

explore: orders {
  view_name: orders
  # other Explore parameters
}

explore: +orders {
  label: "Orders Information"
  # other Explore parameters to build on the original Explore
}

De plus, vous pouvez ajouter un affinement qui inclut un extends. Poursuivant l'exemple, voici la même exploration orders. En outre, il existe une exploration de base appelée users_base. L'affinage +orders comporte désormais un paramètre extends qui importe users_base:


explore: users_base {
  view_name: users
  extension: required
  # other Explore parameters
}

explore: orders {
  view_name: orders
  # other Explore parameters
}

explore: +orders {
  label: "Orders Information"
  extends: [users_base]
  # other Explore parameters to build on the original Explore
}

La particularité ici est que l'affinage +orders contient un extends. Par conséquent, la vue +orders étend désormais l'exploration users_base.

Comment Looker implémente extends dans les raffinements

L'extension d'un objet dans un affinement est un concept LookML avancé. Avant d'utiliser extends dans un affinement, vous devez maîtriser les points suivants:

  • Implémentation de extends par Looker: si un élément LookML est défini à la fois dans l'objet étendu et dans l'objet étendu, la version de l'objet étendu est utilisée, sauf si le paramètre est additif. Pour en savoir plus, consultez la page de documentation Réutiliser du code avec extends.
  • Comment Looker implémente les perfectionnements: si un élément LookML est défini dans plusieurs perfectionnements, le dernier perfectionnement remplace les précédents. Pour en savoir plus, consultez la section Les raffinements sont appliqués dans l'ordre sur cette page.

Enfin, vous devez comprendre comment Looker combine ces principes pour implémenter extends utilisé dans les améliorations. Voici l'ordre d'implémentation de Looker, chaque étape remplaçant la précédente en cas de conflit:

  1. Valeurs de l'extends spécifié dans l'objet
  2. Valeurs de l'extends spécifiées dans les raffinements de l'objet
  3. Valeurs de l'objet
  4. Valeurs des raffinements de l'objet

Pour illustrer, voici un exemple qui suit la valeur du paramètre label à chaque étape de l'implémentation:

explore: orders_base {
  label: "Orders Base"
  view_name: orders
  extension: required
}

explore: users_base {
  label: "Users Base"
  view_name: users
  extension: required
}

explore: orders {
  label: "Orders"
  extends: [orders_base]
}

explore: +orders {
  label: "Orders Refined"
  extends: [users_base]
}

Voici comment Looker implémente la valeur label pour l'exploration orders dans cet exemple:

  1. Valeurs du extends spécifié dans l'objet. Étant donné que l'exploration orders comporte un paramètre extends, Looker commence par les éléments LookML de l'objet étendu, qui est dans ce cas l'exploration orders_base. À ce stade, la valeur label est "Orders Base".
  2. Valeurs de l'extends spécifiées dans les raffinements de l'objet. Étant donné que orders comporte un affinement et que l'affinement comporte un paramètre extends, Looker applique ensuite les éléments LookML de l'extension de l'affinement, qui est dans ce cas l'exploration users_base. À ce stade, la valeur label est "Base d'utilisateurs".
  3. Valeurs de l'objet. Maintenant que toutes les extensions ont été traitées, Looker applique les éléments de l'objet étendu, qui est ici l'exploration orders. En cas de conflit, l'objet étendu l'emporte. La valeur label est donc "Commandes".
  4. Valeurs des raffinements de l'objet. Enfin, Looker applique les éléments de tous les raffinements de l'exploration orders. En cas de conflit, l'objet de précision l'emporte. La valeur label est donc "Orders Refined" (Commandes affinées).

Les filtres extends sont cumulables

Comme décrit dans la section Les paramètres de forçage des raffinements de cette page, les raffinements remplacent généralement les paramètres d'origine d'un objet. Ce n'est pas le cas pour le paramètre extends. Lorsque extends est utilisé dans un affinement, la valeur du paramètre extends est ajoutée à la liste des éléments étendus dans l'objet d'origine ou dans les affinements précédents, le cas échéant. En cas de conflit, la priorité est donnée au dernier élément de la chaîne d'extensions.

Par exemple, voici une exploration de base appelée orders_base et une exploration orders qui étend la base. En outre, il existe une exploration users_base et un affinement +orders qui étend users_base:

explore: orders_base {
  view_name: orders
  extension: required
  # other Explore parameters
}

explore: users_base {
  view_name: users
  extension: required
  # other Explore parameters
}

explore: orders {
  extends: [orders_base]
  # other Explore parameters to build on the base Explore
}

explore: +orders {
  extends: [users_base]
  # other Explore parameters to build on the base Explores
}

L'exploration orders étend orders_base, puis les raffinements +orders ajoutent users_base à la liste extends. L'exploration +orders étend désormais à la fois orders_base et users_base, comme s'il s'agissait du code LookML d'origine de l'exploration:

explore: orders {
  extends: [orders_base, users_base]
}

En cas de conflit, la priorité est donnée au dernier élément de la chaîne d'extensions. Dans cet exemple, les éléments de users_base remplaceraient les éléments en conflit de orders_base.

Le concept d'extension de plusieurs objets à la fois est abordé sur la page de documentation Réutiliser du code avec extends.

Dernière remarque: dans cet exemple, l'ordre des paramètres explore n'a pas d'importance. Toutefois, si vous affinez plusieurs fois le même objet, l'ordre des raffinements a son importance. Comme décrit dans la section Les raffinements sont appliqués dans l'ordre de cette page, le dernier raffinement d'un fichier remplace les précédents.

Utiliser des perfectionnements dans votre projet LookML

Voici les grandes étapes à suivre pour affiner les vues et les explorations de votre projet:

  1. Identifiez la vue ou l'exploration que vous souhaitez affiner.
  2. Déterminez où vous souhaitez héberger vos améliorations. Vous pouvez ajouter des raffinements dans n'importe quel fichier LookML existant ou créer des fichiers LookML distincts pour vos raffinements. (Pour obtenir un exemple de création de fichiers LookML génériques, consultez la procédure de création d'un fichier de test de données sur la page de documentation Comprendre les autres fichiers de projet.)
  3. Utilisez le paramètre include pour intégrer vos améliorations à votre modèle :
    • Dans le fichier dans lequel vous rédigez vos améliorations, vous devez inclure les fichiers du LookML que vous affinez. L'IDE Looker vous envoie des avertissements si vous essayez d'affiner un objet qui n'est pas inclus.
    • Dans votre fichier de modèle, incluez les fichiers dans lesquels vos améliorations sont définies. Vous pouvez combiner des fichiers et utiliser des inclusions de manière très créative. Pour en savoir plus, consultez la section Utiliser des raffinements pour ajouter des calques à votre modèle de cette page.

Exemple

Les perfectionnements des objets LookML permettent d'adapter facilement les vues et les explorations sans avoir à modifier le code LookML d'origine. Cette fonctionnalité est particulièrement utile lorsque vos vues et explorations sont en lecture seule dans votre projet, par exemple avec les fichiers importés depuis d'autres projets. Voici un exemple d'affinage d'une exploration.

Voici le code LookML de l'exploration aircraft:


explore: aircraft {
  join: aircraft_types {
    type: left_outer
    sql_on: ${aircraft.id} = ${aircraft_types.id} ;;
    relationship: many_to_one
  }

  join: aircraft_engine_types {
    type: left_outer
    sql_on: ${aircraft.id} = ${aircraft_engine_types.id} ;;
    relationship: many_to_one
  }
}

Cette exploration contient plusieurs vues, chacune comportant de nombreuses dimensions.

Un autre projet LookML appelé e_faa_refined importe le fichier d'exploration aircraft. Dans le projet e_faa_refined, vous pouvez utiliser un affinement pour simplifier considérablement l'exploration aircraft.

Étant donné que l'exploration aircraft est un fichier importé, vous ne pouvez pas la modifier directement. Vous pouvez plutôt l'affiner. Voici un exemple de fichier distinct appelé refinements.lkml contenant ce code LookML:

include: "//e_faa_original/Explores/aircraft.explore.lkml"

explore: +aircraft {
  label: "Aircraft Simplified"
  fields: [aircraft.aircraft_serial, aircraft.name, aircraft.count]
}

Le fichier refinements.lkml contient les éléments suivants:

  • Le paramètre include pour importer le fichier aircraft.explore.lkml d'origine du projet importé (consultez la page de documentation Importer des fichiers à partir d'autres projets pour savoir comment faire référence aux fichiers de projet importés).
  • Affinements de l'exploration aircraft :
    • Le signe + devant le nom de l'exploration indique qu'elle a été affinée.
    • Le paramètre label remplace le libellé de l'exploration par "Avions simplifiés".
    • Le paramètre fields spécifie que seuls trois champs s'affichent dans l'exploration.

Le résultat final est comme si vous utilisiez la vue aircraft Explorer et aircraft d'origine:

explore: aircraft {
  label: "Aircraft Simplified"
  }

view: aircraft {
  sql_table_name: flightstats.aircraft ;;

  dimension: aircraft_serial {
    type: string
    sql: ${TABLE}.aircraft_serial ;;
  }

  dimension: name {
    type: string
    sql: ${TABLE}.name ;;
  }

  measure: count {
    type: count
  }
}

Pour voir un exemple d'utilisation d'affinements pour personnaliser une seule vue pour plusieurs cas d'utilisation, consultez la recette du livre de recettes Maximiser la réutilisation du code avec DRY LookML: personnaliser une seule vue de base pour plusieurs cas d'utilisation.

Autres cas d'utilisation pour les améliorations

Comme indiqué précédemment, les raffinements sont idéaux pour adapter des objets LookML en lecture seule, tels que les blocs Looker ou les fichiers importés.

Mais une fois que vous aurez compris comment ajouter des améliorations et les inclure dans vos modèles, vous pourrez réaliser des choses très intéressantes avec vos projets, comme décrit dans les exemples suivants.

Utiliser des raffinements pour ajouter des analyses

Vous pouvez utiliser des raffinements pour ajouter des analyses à votre modèle sans modifier les fichiers LookML d'origine. Par exemple, si les vues et les explorations d'un projet sont générées à partir de tables de votre base de données et stockées dans un fichier LookML appelé faa_basic.lkml, vous pouvez créer un fichier faa_analysis.lkml dans lequel vous utiliserez des perfectionnements pour ajouter des analyses. Voici un exemple de nouvelle table dérivée appelée distance_stats avec une analyse de distance. Cet exemple montre des améliorations de l'exploration flights existante à partir du fichier faa_basic.lkml qui joint la table dérivée distance_stats à l'exploration flights. En bas de l'exemple, la vue flights existante est affinée pour ajouter de nouveaux champs à partir de l'analyse:

include: "faa_basic.lkml"

explore: +flights {
  join: distance_stats {
    relationship: one_to_one
    type: cross
  }
}

view: distance_stats {
  derived_table: {
    explore_source: flights {
      bind_all_filters: yes
      column: distance_avg {field:flights.distance_avg}
      column: distance_stddev {field:flights.distance_stddev}
    }
  }
  dimension: avg {
    type:number
    sql: CAST(${TABLE}.distance_avg as INT64) ;;
  }
  dimension: stddev {
    type:number
    sql: CAST(${TABLE}.distance_stddev as INT64) ;;
  }
}
view: +flights {
  measure: distance_avg {
    type: average
    sql: ${distance} ;;
  }
  measure: distance_stddev {
    type: number
    sql: STDDEV(${distance}) ;;
  }
  dimension: distance_tiered2 {
    type: tier
    sql: ${distance} ;;
    tiers: [500,1300]
  }
}

Utiliser des améliorations pour ajouter des calques à votre modèle

Un autre cas d'utilisation intéressant des améliorations consiste à ajouter des calques à votre projet. Vous pouvez créer plusieurs fichiers d'affinage, puis les inclure de manière stratégique pour ajouter des calques.

Par exemple, dans le projet FAA, un fichier faa_raw.lkml contient toutes les vues et explorations générées à partir des tables de votre base de données. Ce fichier contient une vue pour chaque table de la base de données, avec une dimension pour chaque colonne de la base de données.

En plus du fichier brut, vous pouvez créer un fichier faa_basic.lkml pour ajouter un calque avec des améliorations de base, comme ajouter des jointures à vos explorations ou des mesures à vos vues, comme suit:

include: "faa_raw.lkml"

explore: +flights {
  join: carriers {
    sql_on: ${flights.carrier} = ${carriers.name} ;;
  }
}

view: +flights {
  measure: total_seats {
    type: sum
    sql: ${aircraft_models.seats} ;;
  }
}

Vous pouvez ensuite ajouter un fichier faa_analysis.layer.lkml pour ajouter un calque avec des analyses (voir la sous-section Utiliser des raffinements pour ajouter des analyses pour obtenir un exemple de fichier d'analyse).

Il vous suffit ensuite d'inclure tous les fichiers d'affinage dans le fichier de modèle. Vous pouvez également utiliser le fichier de modèle pour ajouter des précisions afin de diriger vos vues vers les tables de base de données que vous souhaitez référencer:

connection: "publicdata_standard_sql"

include: "faa_raw.lkml"
include: "faa_basic.lkml"
include: "faa_analysis.lkml"

view: +flights {
  sql_table_name: lookerdata.faa.flights;;
}
view: +airports {
  sql_table_name: lookerdata.faa.airports;;
}
view: +aircraft {
  sql_table_name: lookerdata.faa.aircraft;;
}
view: +aircraft_models{
  sql_table_name: lookerdata.faa.aircraft_models;;
}
view: +carriers {
  sql_table_name: lookerdata.faa.carriers;;
}

Vous pouvez dupliquer ce fichier de modèle et faire pointer vers différentes tables de base de données, ou inclure différents fichiers d'affinage que vous avez créés pour définir d'autres calques souhaités dans votre modèle.

Utiliser des raffinements pour les tables PDT

Comme décrit dans la section Améliorations par rapport aux extensions de cette page, une extension crée une copie de l'objet étendu. Dans le cas des tables dérivées persistantes (PDT), vous ne devez pas utiliser d'extensions, car chaque extension d'une table dérivée persistante crée une nouvelle copie de la table dans votre base de données.

Toutefois, vous pouvez ajouter des précisions à la vue du PDT, car elles ne créent pas de copie de l'objet en cours d'affinage.

Utiliser des métadonnées pour afficher les précisions d'un objet

Vous pouvez cliquer sur un paramètre explore ou view dans l'IDE Looker, puis utiliser le panneau des métadonnées pour afficher les améliorations apportées à l'objet. Pour en savoir plus, consultez la page de documentation Métadonnées des objets LookML.

Éléments à prendre en compte

Projets avec localisation

Lorsque vous affinez un objet, sachez que les règles de localisation s'appliquent également à vos affinages. Si vous affinez un objet, puis définissez de nouveaux libellés ou descriptions, vous devez fournir des définitions de localisation dans les fichiers de chaînes de paramètres régionaux de votre projet. Pour en savoir plus, consultez la page de documentation Localiser votre modèle LookML.