Refinamientos de LookML

Información general

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

Por ejemplo, si tiene el siguiente archivo de vista en su proyecto:

view: flights {
  sql_table_name: flightstats.accidents ;;

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

Puedes acotar la vista flights como se muestra en el siguiente ejemplo: usa el parámetro view con el mismo nombre de vista, pero añade un signo más (+) delante del nombre para indicar que se trata de una acotación de una vista que ya existe.

Esta función añade una dimensión air_carrier a la vista flights:

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

Este refinamiento se puede incluir en cualquier archivo LookML del proyecto, como un archivo de modelo o de vista, o en su propio archivo LookML específico. Consulta la sección Usar refinamientos en tu proyecto de LookML para saber cómo funciona.

La combinación del refinamiento con el LookML original da como resultado final el mismo resultado que 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 interfaz de usuario de Looker, los usuarios verán la dimensión Aerolínea, como si la hubieras añadido al archivo de vista original.

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

Mejoras en comparación con las extensiones

Looker también permite ampliar objetos de LookML. La opción de ampliar es útil cuando quieres crear una copia de una vista o de una exploración para añadirle objetos. Por ejemplo, puedes crear una vista base que defina todos tus campos y, a continuación, crear varias vistas nuevas que amplíen la vista base. Estas nuevas vistas se pueden modificar para ocultar determinados campos de la vista base o para cambiar las definiciones o las etiquetas de los campos de la vista base.

Los refinamientos son útiles cuando quiere modificar una vista o un Exploración con algunos ajustes en determinados objetos, pero no quiere crear copias de la vista o del Exploración. Los refinamientos son ideales en situaciones en las que no puedes o no quieres modificar la vista o el Explorar base, así como en situaciones en las que crear una vista o un Explorar nuevos requeriría cambios importantes en otras referencias de LookML. Consulta la sección Ejemplo de esta página para ver un ejemplo de este caso práctico.

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

Los desarrolladores de LookML avanzados pueden usar el parámetro extends dentro de un refinamiento de LookML. Consulta más información en la sección Los refinamientos pueden contener extensiones de esta página.

Las acotaciones anulan la mayoría de los parámetros

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

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

En otro archivo, se ha refinado esa dimensión con hidden: no:


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

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

La última opción de refinamiento tiene prioridad, por lo que se aplica hidden: no y la dimensión se muestra en la vista final.

En algunos casos, las acotaciones son aditivas en lugar de sustitutivas. Consulte la sección Algunos parámetros son aditivos de esta página para obtener más información.

Algunos parámetros son acumulativos

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

Sin embargo, las optimizaciones pueden ser aditivas en algunos parámetros, lo que significa que los valores del objeto base se usan junto con los valores del objeto optimizado.

Los siguientes parámetros son aditivos:

Por ejemplo, aquí tienes 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 una versión mejorada 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, los dos parámetros link son aditivos, por lo que la dimensión name mostrará ambos enlaces.

Los ajustes se aplican en orden

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

  • En un proyecto, los refinamientos se aplican en el orden en el que se incluyen sus archivos. Los refinamientos de los archivos incluidos en último lugar anularán los de los archivos incluidos anteriormente.
  • En un mismo archivo, los refinamientos se aplican línea por línea hacia abajo. Los refinamientos con el número de línea más alto se aplican en último lugar 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 la muestra (hidden: no). Cuando hay conflictos como este, prevalece el refinamiento que se encuentra más abajo en el archivo: 

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: las mejoras del último archivo que se incluya tendrán prioridad. Por ejemplo, si un archivo de modelo incluye estos archivos:

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

Primero se aplicarán las mejoras de la distance_analysis.lkml y, después, las del archivo finishing_touches.lkml. Si hay algún conflicto, prevalecerán los refinamientos del último archivo, finishing_touches.lkml.

Usar final: yes para evitar más refinamientos

Como se ha descrito anteriormente, el mismo objeto se puede perfeccionar varias veces en varios lugares, y el último perfeccionamiento sustituirá a todos los anteriores.

Si quieres que un refinamiento se considere el definitivo para la vista o el Explorador, puedes añadirle la marca final: yes. El IDE de Looker devolverá un error de LookML si hay refinamientos que se aplicarían después de este refinamiento final o si un desarrollador intenta añadir un nuevo refinamiento que se aplicaría después de este refinamiento final. Por ejemplo, la segunda modificación de este archivo de vista crearía un error de LookML porque la modificación 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
  }
}

Añadir la marca final: yes a una acotación es una buena forma de verificar que las acotaciones se aplican en el orden que quieres.

Los refinamientos pueden contener extensiones

Los desarrolladores de LookML avanzados pueden usar un parámetro extends dentro de un refinamiento de LookML, que añade el objeto ampliado al objeto que se está refinando.

Para resumir el comportamiento de extends y los refinamientos:

  • Al ampliar un objeto, se crea una copia del objeto y se trabaja a partir de ella. Por ejemplo, puedes crear una vista base que defina todos tus campos y, a continuación, crear varias vistas nuevas que amplíen la vista base. Cada una de estas nuevas vistas incorporará una copia de la vista base y, a partir de ahí, un desarrollador podrá añadir diferentes campos, filtros u otras propiedades para modificar el contenido de la vista base. La idea es que empieces con un objeto base y luego lo uses de diferentes formas en varios objetos. Puedes consultar la página de documentación Reutilizar código con extends para obtener información detallada sobre cómo trabajar con extends.
  • Al perfeccionar un objeto, se añade una capa de modificaciones al objeto, pero, a diferencia de la extensión, no se hacen varias copias del objeto. La idea es crear un objeto base sin modificar su LookML original.

A continuación, se muestra un ejemplo del uso estándar de los refinamientos. Se trata de una exploración llamada orders y la exploración +orders que la 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 añadir un refinamiento que incluya un extends. Siguiendo con el ejemplo, aquí tienes la misma ordersexploración. Además, hay una Exploración base llamada users_base y, ahora, el refinamiento +orders tiene un parámetro extends que incluye 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 de este caso es que el refinamiento +orders tiene un extends en su interior. Como resultado, la vista +orders ahora se extenderá a la sección users_base Explorar.

Cómo implementa Looker extends en los refinamientos

Extender un objeto dentro de un refinamiento es un concepto avanzado de LookML. Antes de usar extends en una acotación, debes conocer 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 extensor, se usa la versión del objeto extensor, a menos que el parámetro sea aditivo. Consulta la página de documentación 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 refinamiento anula los anteriores. Consulta la sección Los refinamientos se aplican en orden de esta página para obtener más información.

Por último, debes saber cómo combina Looker estos principios para implementar extends que se usan en los refinamientos. Este es el orden que sigue Looker, en el que cada paso anula el anterior en caso de conflicto:

  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 la exploración orders en este ejemplo:

  1. Valores del extends especificado en el objeto. Como el Explore orders tiene un parámetro extends, Looker empieza con los elementos de LookML del objeto que se está ampliando, que en este caso es el Explore orders_base. En este punto, el valor de label es "Orders Base".
  2. Valores del extends especificado en los refinamientos del objeto. Como orders tiene un refinamiento y este tiene un parámetro extends, Looker aplica los elementos de LookML de la extensión del refinamiento, que en este caso es la Exploración users_base. En este punto, el valor de label es "Users Base".
  3. Valores del objeto. Ahora que se han abordado todas las extensiones, Looker aplica elementos del objeto de extensión, que en este caso es el Explore orders. Si hay algún conflicto, prevalece el objeto que extiende. Ahora, el valor de label es "Pedidos".
  4. Valores de las refinas del objeto. Por último, Looker aplica los elementos de los refinamientos de la orders exploración. Si hay algún conflicto, prevalecerá el objeto de refinamiento. Ahora, el valor de label es "Pedidos refinados".

Los filtros extends son acumulativos

Como se describe en la sección Parámetros de anulación de los refinamientos de esta página, los refinamientos suelen anular la configuración original de un objeto. No es el caso del parámetro extends. Cuando se usa extends en un refinamiento, el valor del parámetro extends se añade a la lista de elementos ampliada en el objeto original o en refinamientos anteriores, si los hay. Después, si hay algún conflicto, se da prioridad al último elemento de la cadena de extensiones.

Por ejemplo, aquí tenemos una Exploración base llamada orders_base y una Exploración orders que amplía la base. Además, hay una users_base exploración y un +orders refinamiento que amplía 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
}

La función orders Explorar amplía la orders_base y, a continuación, la función +orders Refinamientos añade la users_base a la lista extends. El resultado es que +orders Explore ahora se extenderá a orders_base y users_base, como si este fuera el LookML original de Explore:

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

Después, si hay algún conflicto, se da prioridad al último elemento de la cadena de extensiones. En este ejemplo, los elementos de users_base anularían los elementos de orders_base que entraran en conflicto.

El concepto de ampliar más de un objeto a la vez se explica en la página de documentación Reutilizar código con extends.

Por último, en este ejemplo, el orden de los parámetros explore no importa. Sin embargo, en los casos en los que se aplican varios refinamientos al mismo objeto, el orden de los refinamientos sí importa. Tal 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 anteriores.

Usar refinamientos en un proyecto de LookML

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

  1. Identifica la vista o el Explorar que quieras acotar.
  2. Decide dónde quieres guardar tus refinamientos. Puedes añadir ajustes en cualquier archivo LookML que ya tengas o crear archivos LookML independientes para tus ajustes. Para ver un ejemplo de cómo crear archivos LookML genéricos, consulta el procedimiento para crear un archivo de prueba de datos en la página de documentación Información sobre otros archivos de proyecto.
  3. Usa el parámetro include para incorporar tus ajustes al modelo:
    • En el archivo en el que escribas 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 el archivo del modelo, incluya los archivos en los que se definen los refinamientos. Puedes combinar archivos y usar inclusiones de formas muy creativas. Consulta la sección Usar refinamientos para añadir capas a tu modelo de esta página para obtener más información.

Ejemplo

Refinar objetos de LookML es una forma sencilla de adaptar vistas y Exploraciones sin tener que editar el LookML original. Esto es especialmente útil cuando tus vistas y Exploraciones son de solo lectura en tu proyecto, como en el caso de los archivos importados de otros proyectos. Aquí tienes un ejemplo de cómo acotar una exploración.

Este es el LookML de 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 de las cuales tiene muchas dimensiones.

Ahora, otro proyecto de LookML llamado e_faa_refined importa el archivo Exploración aircraft. En el proyecto e_faa_refined, puedes usar un acotamiento para simplificar considerablemente la exploración aircraft.

Como el archivo aircraft Explorar es un archivo importado, no puedes editarlo directamente. En su lugar, puedes añadir un refinamiento. A continuación, se muestra un ejemplo de un archivo independiente llamado refinements.lkml que contiene este 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 (consulte la página de documentación Importar archivos de otros proyectos para obtener información sobre cómo hacer referencia a los archivos de proyectos importados).
  • Mejoras en la función aircraft Explorar:
    • El signo + delante del nombre de la exploración indica que se trata de una búsqueda restringida de una exploración ya creada.
    • El parámetro label cambia la etiqueta del gráfico Exploración a "Aviones simplificado".
    • El parámetro fields especifica que solo se mostrarán tres campos en Explorar.

El resultado final es como si se tratara de las vistas aircraft Explorar y aircraft original:

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 de cómo usar los refinamientos para personalizar una sola vista en varios casos prácticos, consulta la receta Maximizar la reutilización del código con DRY LookML: personalizar una sola vista base para varios casos prácticos.

Otros casos prácticos de los refinamientos

Como hemos mencionado anteriormente, los refinamientos son ideales para adaptar objetos de LookML de solo lectura, como los bloques de Looker o los archivos importados.

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

Usar refinamientos para añadir análisis

Puedes usar los refinamientos para añadir análisis a tu modelo sin modificar los archivos 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 añadir análisis. Aquí tienes un ejemplo de una tabla derivada llamada distance_stats que incluye un análisis de distancia. En este ejemplo se muestra una mejora de la exploración flights del archivo faa_basic.lkml que une la tabla derivada distance_stats a la exploración flights. Además, en la parte inferior del ejemplo, se ha perfeccionado la flights vista para añadir 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]
  }
}

Usar refinamientos para añadir capas a tu modelo

Otro caso práctico interesante de los refinamientos es añadir capas a tu proyecto. Puedes crear varios archivos de refinamiento e incluirlos estratégicamente para añadir capas.

Por ejemplo, en el proyecto FAA hay un archivo faa_raw.lkml que contiene todas las vistas y los Exploraciones que se han generado a partir de las tablas de tu base de datos. Este archivo tiene una vista para cada tabla de la base de datos, y cada una de ellas tiene una dimensión para cada columna de la base de datos.

Además del archivo sin procesar, puedes crear un archivo faa_basic.lkml para añadir una nueva capa con ajustes básicos, como añadir combinaciones a tus Exploraciones o medidas a tus vistas. Por ejemplo:

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

A continuación, puedes añadir un archivo faa_analysis.layer.lkml para añadir una nueva capa con análisis (consulta la subsección Usar refinamientos para añadir análisis para ver un ejemplo de archivo de análisis).

A partir de ahí, solo tienes que incluir todos los archivos de refinamiento en el archivo del modelo. También puedes usar el archivo de modelo para añadir ajustes y dirigir tus vistas a las tablas de la base de datos a las que quieras 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 dirigirlo a otras tablas de la base de datos, o bien incluir otros archivos de refinamiento que hayas creado para definir otras capas que quieras incluir en el modelo.

Usar búsquedas restringidas en PDTs

Tal como se describe en la sección Diferencias entre las mejoras y las extensiones de esta página, una extensión crea una copia nueva del objeto que se está extendiendo. En el caso de las tablas derivadas persistentes (PDTs), no deberías 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 añadir refinamientos a la vista del PDT, ya que los refinamientos no crean una copia nueva del objeto que se está refinando.

Usar metadatos para ver los refinamientos de un objeto

Puede hacer clic en un parámetro explore o view en el IDE de Looker y usar el panel de metadatos para ver los cambios que se han hecho en el objeto. Para obtener información, consulta la página de documentación Metadatos de objetos LookML.

Cuestiones que debes tener en cuenta

Proyectos con localización

Cuando refines un objeto, ten en cuenta que las reglas de localización también se aplican a tus refinamientos. Si vas a perfeccionar un objeto y, después, definir nuevas etiquetas o descripciones, debes proporcionar definiciones de localización en los archivos de cadenas de configuración regional de tu proyecto. Para obtener más información, consulta la página de documentación Localizar tu modelo de LookML.