Refinamientos de LookML

Descripción general

Con los perfeccionamientos de LookML, puedes adaptar una vista o un Explorar existentes sin editar el archivo de LookML que los contiene. Es ideal para lo siguiente:

Por ejemplo, si tienes el siguiente archivo de vista en tu proyecto:

view: flights {
  sql_table_name: flightstats.accidents ;;

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

Puedes definir mejor la vista flights como se muestra en el siguiente ejemplo: Usa el parámetro view con el mismo nombre de vista, pero agrega un signo más (+) delante del nombre para indicar que es una definición mejorada de una vista existente.

Este perfeccionamiento agrega una dimensión air_carrier a la vista flights existente:

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

Este perfeccionamiento puede incluirse en cualquier archivo de LookML del proyecto, como un archivo de modelo, un archivo de vista o en su propio archivo de LookML dedicado. Consulta la sección Cómo usar refinamientos en tu proyecto de LookML para saber cómo funciona.

El perfeccionamiento combinado con el LookML original tiene el resultado final como si este fuera el LookML original de la vista:

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 ;;
  }
}

En la IU de Looker, los usuarios verán la dimensión Air Carrier, como si la hubieras agregado al archivo de vista original.

Consulta la sección Ejemplo para obtener información más detallada sobre la implementación.

Comparación entre los refinamientos y las extensiones

Looker también admite la extensión de objetos LookML. La extensión es útil cuando deseas crear una copia nueva de una vista o un Explorar existentes para poder agregarle objetos nuevos. Por ejemplo, puedes crear una vista base que defina todos tus campos y, luego, crear varias vistas nuevas que extiendan la vista base. Luego, estas vistas nuevas se pueden modificar para ocultar ciertos campos en la vista base o para cambiar las definiciones o etiquetas de los campos de la vista base.

Los ajustes son útiles cuando deseas modificar una vista o un Explorar existentes con algunos retoques o ajustes en ciertos objetos, pero no quieres crear copias de la vista o el Explorar. Los refinamientos son ideales para situaciones en las que no puedes o no quieres modificar la vista o la función Explorar base, y para situaciones en las que crear una vista o una función Explorar nuevas requeriría cambios extensos en otras referencias de LookML. Consulta la sección Ejemplo en esta página para ver un ejemplo de este caso de uso.

En la mayoría de los casos de uso, los refinamientos son una alternativa más simple y clara a extends.

Es posible que los desarrolladores avanzados de LookML deseen usar el parámetro extends dentro de un perfeccionamiento de LookML. Consulta la sección Los refinamientos pueden contener extensiones en esta página para obtener más información.

Los refinamientos anulan la mayoría de los parámetros

Es importante tener en cuenta que, en la mayoría de los casos, un perfeccionamiento anulará la configuración original de un objeto. En el siguiente ejemplo, la vista original tiene una dimensión oculta (hidden: yes):

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

Y en otro archivo, hay un perfeccionamiento de esa dimensión con hidden: no:


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

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

La última refinación tiene prioridad, por lo que se aplica hidden: no y la dimensión se mostrará en la vista final.

En algunos casos, los ajustes son aditivos en lugar de anularse. Consulta la sección Algunos parámetros son aditivos de esta página para obtener más información.

Algunos parámetros son aditivos

En muchos casos, si el refinamiento contiene el mismo parámetro que el objeto que se refina, el refinamiento anulará los valores de los parámetros del objeto refinado.

Sin embargo, los refinamientos pueden ser aditivos para algunos parámetros, lo que significa que los valores del objeto base se usan junto con los valores del objeto refinado.

Los siguientes parámetros son aditivos:

Por ejemplo, a continuación, se muestra una vista que tiene una dimensión name con un parámetro 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"
    }
  }
}

A continuación, se muestra un perfeccionamiento de la vista carriers, con una dimensión name que tiene diferentes valores para el parámetro 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"
    }
  }
}

En la vista carriers refinada, los dos parámetros link son aditivos, por lo que la dimensión name mostrará ambos vínculos.

Las mejoras se aplican en orden

Un objeto se puede perfeccionar varias veces y en varios lugares, lo que permite a los desarrolladores de Looker usar perfeccionamientos de muchas maneras creativas. Sin embargo, esto también significa que los desarrolladores deben tener muy en cuenta el orden en el que se aplican los refinamientos:

  • Dentro de un proyecto, los ajustes se aplican en el orden en que se incluyen sus archivos. Los ajustes de los archivos incluidos al final anularán los ajustes de los archivos incluidos antes.
  • Dentro de un mismo archivo, los refinamientos se aplican línea por línea de arriba hacia abajo. Los refinamientos con el número de línea más alto se aplican al final y anularán cualquier refinamiento anterior si hay conflictos.

Por ejemplo, en el siguiente archivo de vista, hay dos refinamientos de la vista faa_flights. El primer refinamiento oculta una dimensión (hidden: yes), y el segundo muestra la dimensión (hidden: no). Cuando hay conflictos como este, el refinamiento que se encuentra más abajo en el archivo tiene prioridad: 

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

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

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

La lógica es similar para incluir varios archivos en un proyecto: tendrán prioridad los refinamientos del último archivo que se incluya en la lista. Por ejemplo, si un archivo de modelo incluye estos archivos:

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

Primero, se aplicarán los ajustes en distance_analysis.lkml y, luego, los ajustes en el archivo finishing_touches.lkml. Si hay conflictos, tendrán prioridad los refinamientos del último archivo, finishing_touches.lkml.

Usa final: yes para evitar más ajustes

Como se describió anteriormente, el mismo objeto se puede refinar varias veces en varios lugares, y el último refinamiento anulará todos los refinamientos anteriores.

Si tienes un perfeccionamiento que deseas que se considere el perfeccionamiento final para la vista o la Exploración, puedes agregar la marca final: yes al perfeccionamiento. El IDE de Looker devolverá un error de LookML si hay refinamientos existentes que se aplicarían después de este refinamiento final o si un desarrollador intenta agregar un refinamiento nuevo que se aplicaría después de este refinamiento final. Por ejemplo, el segundo perfeccionamiento en este archivo de vista crearía un error de LookML porque el perfeccionamiento anterior tiene la marca 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
  }
}

Agregar la marca final: yes a un refinamiento es una buena manera de verificar que los refinamientos se apliquen en el orden deseado.

Los refinamientos pueden contener extensiones

Es posible que los desarrolladores avanzados de LookML deseen usar un parámetro extends dentro de un perfeccionamiento de LookML, que agrega el objeto extendido al objeto que se perfecciona.

A continuación, se resume el comportamiento de extends y los ajustes:

  • Extender un objeto crea una copia nueva del objeto y, luego, se basa en ella. Por ejemplo, puedes crear una vista base que defina todos tus campos y, luego, crear varias vistas nuevas que extiendan la vista base. Cada una de estas vistas nuevas incorporará una copia de la vista base y, desde allí, un desarrollador podrá agregar diferentes campos, filtros o cualquier otra propiedad para modificar el contenido de la vista base. La idea es que comiences con un objeto base y, luego, lo uses de diferentes maneras en varios otros objetos. (Puedes consultar la página de documentación Reutilización de código con extends para obtener una explicación completa sobre cómo trabajar con extends).
  • Refinar un objeto agrega una capa de modificaciones al objeto, pero, a diferencia de extender, refinar no crea varias copias del objeto. La idea es basarse en un objeto base sin modificar su código LookML original.

Como ejemplo del uso estándar de los refinamientos, aquí se muestra un Explore llamado orders y el Explore +orders que lo refina:

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

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

Además, puedes agregar un refinamiento que incluya un extends. Basándonos en el ejemplo, aquí se muestra la misma Exploración de orders. Pero, además, hay una exploración básica llamada users_base, y ahora el refinamiento +orders tiene un parámetro extends que incorpora la exploración 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
}

Lo especial aquí es que el refinamiento de +orders tiene un extends dentro. El resultado es que la vista +orders ahora extenderá la Exploración users_base.

Cómo implementa Looker extends dentro de los refinamientos

Extender un objeto dentro de un perfeccionamiento es un concepto avanzado de LookML. Antes de usar extends en un refinamiento, debes comprender en profundidad lo siguiente:

  • Cómo implementa Looker extends: Si un elemento de LookML se define tanto en el objeto extendido como en el objeto extendente, se usa la versión del objeto extendente, a menos que el parámetro sea aditivo. Consulta la página de documentación Cómo reutilizar código con extends para obtener más información.
  • Cómo implementa Looker los refinamientos: Si un elemento de LookML se define en varios refinamientos, el último anula los anteriores. Para obtener más información, consulta la sección Los refinamientos se aplican en orden en esta página.

Por último, debes comprender cómo Looker combina estos principios para implementar extends que se usa en los refinamientos. Este es el orden en el que Looker implementa los pasos, y cada uno anula el anterior en caso de conflictos:

  1. Valores del extends especificado en el objeto
  2. Valores del extends especificado en los refinamientos del objeto
  3. Valores del objeto
  4. Valores de los refinamientos del objeto

Para ilustrarlo, aquí tienes un ejemplo que sigue el valor del parámetro label en cada paso de la implementación:

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]
}

Así es como Looker implementa el valor de label para el Explorar orders en este ejemplo:

  1. Valores del extends especificado en el objeto. Dado que la Exploración orders tiene un parámetro extends, Looker comienza con los elementos de LookML del objeto que se extiende, que, en este caso, es la Exploración orders_base. En este punto, el valor de label es "Orders Base".
  2. Valores del extends especificado en los refinamientos del objeto. Dado que orders tiene un perfeccionamiento y este tiene un parámetro extends, Looker aplica los elementos de LookML de la extensión del perfeccionamiento, que, en este caso, es el Explorar users_base. En este punto, el valor de label es "Base de usuarios".
  3. Valores del objeto. Ahora que se abordaron todas las extensiones, Looker aplica elementos del objeto de extensión, que, en este caso, es el Explorar orders. Si hay conflictos, gana el objeto que extiende. Ahora, el valor de label es "Pedidos".
  4. Valores de las segmentaciones del objeto. Por último, Looker aplica elementos de cualquier perfeccionamiento del Explorar orders. Si hay conflictos, prevalece el objeto de refinamiento. Ahora, el valor de label es "Pedidos perfeccionados".

Las mejoras extends son acumulativas

Como se describe en la sección Parámetros de anulación de refinamientos de esta página, los refinamientos suelen anular la configuración original de un objeto. Este no es el caso del parámetro extends. Cuando se usa extends en un refinamiento, el valor del parámetro extends se agrega a la lista de elementos extendidos en el objeto original o en los refinamientos anteriores, si los hay. Luego, si hay conflictos, se le da prioridad al último elemento de la cadena de extensiones.

Por ejemplo, aquí se muestra un Explore base llamado orders_base y un Explore orders que extiende el base. Además, hay una exploración users_base y un refinamiento +orders que extiende 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
}

El orders Explore extiende el orders_base y, luego, los refinamientos de +orders agregan el users_base a la lista de extends. El resultado es que la exploración +orders ahora extenderá orders_base y users_base, como si este fuera el LookML original de la exploración:

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

Luego, si hay conflictos, se le da prioridad al último elemento de la cadena de extensiones. En este ejemplo, los elementos de users_base anularían cualquier elemento en conflicto de orders_base.

El concepto de extender más de un objeto a la vez se analiza en la página de documentación Cómo reutilizar código con extends.

Una última cosa que debes tener en cuenta: En este ejemplo, el orden de los parámetros explore no importa. Sin embargo, en los casos con varios refinamientos del mismo objeto, el orden de los refinamientos sí importa. Como se describe en la sección Los refinamientos se aplican en orden de esta página, el último refinamiento de un archivo anula los refinamientos anteriores.

Cómo usar refinamientos en tu proyecto de LookML

Estos son los pasos generales para refinar las vistas y las Exploraciones en tu proyecto:

  1. Identifica la vista o la función Explorar que deseas ajustar.
  2. Decide dónde quieres almacenar tus refinamientos. Puedes agregar refinamientos en cualquier archivo LookML existente o crear archivos LookML separados para tus refinamientos. (Consulta el procedimiento para crear un archivo de prueba de datos en la página de documentación Cómo comprender otros archivos del proyecto para ver un ejemplo de cómo crear archivos genéricos de LookML).
  3. Usa el parámetro include para incorporar tus ajustes en el modelo:
    • En el archivo en el que escribes tus refinamientos, debes incluir los archivos del LookML que estás refinando. El IDE de Looker te mostrará advertencias si intentas refinar un objeto que no está incluido.
    • En tu archivo de modelo, incluye los archivos en los que se definen tus refinamientos. Puedes combinar archivos y usar inclusiones de formas muy creativas. Consulta la sección Cómo usar refinamientos para agregar capas a tu modelo en esta página para obtener más detalles.

Ejemplo

Refinar objetos de LookML es una forma sencilla de adaptar las vistas y los Explorar sin tener que editar el LookML original. Esto es especialmente útil cuando tus vistas y Exploraciones son de solo lectura en tu proyecto, como con los archivos importados de otros proyectos. A continuación, se muestra un ejemplo de cómo definir mejor una exploración.

A continuación, se muestra el código LookML para la exploración 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
  }
}

Esta exploración contiene varias vistas, cada una con muchas dimensiones.

Ahora, otro proyecto de LookML llamado e_faa_refined importa el archivo de Explore aircraft. En el proyecto e_faa_refined, puedes usar un refinamiento para simplificar drásticamente la Exploración aircraft.

Debido a que la aircraft Explorar es un archivo importado, no puedes editarlo directamente. En cambio, puedes agregarle un refinamiento. A continuación, se muestra un ejemplo de un archivo independiente llamado refinements.lkml que contiene este código LookML:

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

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

El archivo refinements.lkml contiene lo siguiente:

  • El parámetro include para incorporar el archivo aircraft.explore.lkml original del proyecto importado (consulta la página de documentación Importing files from other projects para obtener detalles sobre cómo hacer referencia a los archivos del proyecto importado)
  • Mejoras en la función aircraft Explorar:
    • El signo + delante del nombre de la Exploración indica que se trata de una mejora de una Exploración existente.
    • El parámetro label cambia la etiqueta de Explorar a "Aviones simplificados".
    • El parámetro fields especifica que solo se mostrarán tres campos en Explorar.

El resultado final es como si esta fuera la vista original de aircraft Explorar y aircraft:

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
  }
}

Para ver un ejemplo del uso de refinamientos para personalizar una sola vista para varios casos de uso, consulta la receta de la guía Maximizing code reusability with DRY LookML: Customizing a single base view for multiple use cases.

Otros casos de uso para los refinamientos

Como se mencionó anteriormente, los perfeccionamientos son ideales para adaptar objetos de LookML de solo lectura, como los Looker Blocks o los archivos importados.

Sin embargo, una vez que te familiarices con la adición de ajustes y su inclusión en tus modelos, podrás hacer cosas muy interesantes con tus proyectos, como se describe en los siguientes ejemplos.

Cómo usar los refinamientos para agregar análisis

Puedes usar refinamientos para agregar análisis a tu modelo sin modificar los archivos de LookML originales. Por ejemplo, si hay un proyecto en el que las vistas y las Exploraciones se generan a partir de tablas de tu base de datos y se almacenan en un archivo de LookML llamado faa_basic.lkml, puedes crear un archivo faa_analysis.lkml en el que uses refinamientos para agregar análisis. A continuación, se muestra un ejemplo de una nueva tabla derivada llamada distance_stats que tiene un análisis de distancia. En este ejemplo, se muestra un perfeccionamiento del flights Explore existente del archivo faa_basic.lkml que une la tabla derivada distance_stats en el flights Explore. Además, en la parte inferior del ejemplo, se refina la vista flights existente para agregar nuevos campos del análisis:

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]
  }
}

Cómo usar los ajustes para agregar capas a tu modelo

Otro caso de uso interesante de los ajustes es agregar capas a tu proyecto. Puedes crear varios archivos de perfeccionamiento y, luego, incluirlos de forma estratégica para agregar capas.

Por ejemplo, en el proyecto de la FAA, hay un archivo faa_raw.lkml que contiene todas las vistas y los Explorar que se generaron a partir de las tablas de tu base de datos. Este archivo tiene una vista para cada tabla de la base de datos, cada una con dimensiones para cada columna de la base de datos.

Además del archivo sin procesar, puedes crear un archivo faa_basic.lkml para agregar una nueva capa con ajustes básicos, como agregar uniones a tus Exploraciones o agregar medidas a tus vistas, de la siguiente manera:

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} ;;
  }
}

Luego, puedes agregar un archivo faa_analysis.layer.lkml para agregar una capa nueva con análisis (consulta la subsección Cómo usar refinamientos para agregar análisis para ver un ejemplo de un archivo de análisis).

Luego, solo debes incluir todos los archivos de perfeccionamiento en el archivo del modelo. También puedes usar el archivo del modelo para agregar refinamientos y dirigir tus vistas a las tablas de la base de datos a las que deseas hacer referencia:

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;;
}

Puedes duplicar este archivo de modelo y apuntar a diferentes tablas de bases de datos, o bien puedes incluir diferentes archivos de refinamiento que hayas creado para definir otras capas que desees en tu modelo.

Cómo usar refinamientos para PDT

Como se describe en la sección Comparación entre las extensiones y los refinamientos de esta página, una extensión crea una copia nueva del objeto que se extiende. En el caso de las tablas derivadas persistentes (PDT), no debes usar extensiones, ya que cada extensión de una PDT creará una copia nueva de la tabla en tu base de datos.

Sin embargo, puedes agregar refinamientos a la vista del PDT, ya que los refinamientos no crean una copia nueva del objeto que se refina.

Cómo usar los metadatos para ver los refinamientos de un objeto

Puedes hacer clic en un parámetro explore o view en el IDE de Looker y usar el panel de metadatos para ver los ajustes del objeto. Consulta la página de documentación Metadatos para objetos de LookML para obtener más información.

Aspectos para tener en cuenta

Proyectos con localización

Cuando definas un objeto, ten en cuenta que las reglas de localización también se aplican a tus definiciones. Si refinas un objeto y, luego, defines etiquetas o descripciones nuevas, debes proporcionar definiciones de localización en los archivos de cadenas de configuración regional de tu proyecto. Consulta la página de documentación Cómo localizar tu modelo de LookML para obtener más información.